diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index f73a27a11..90d3f5d57 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,20 +1,21 @@
 {
   "image": "mcr.microsoft.com/devcontainers/universal:2",
   "features": {
     "ghcr.io/devcontainers/features/common-utils:1": {
       "version": "latest"
     },
     "ghcr.io/devcontainers/features/github-cli:1": {
         "version": "latest"
     },
     "ghcr.io/devcontainers/features/git-lfs:1": {
       "version": "latest"
     },
     "ghcr.io/devcontainers/features/sshd:1": {
       "version": "latest"
     }, 
     "ghcr.io/devcontainers/features/dotnet:1": {
-      "version": "7.0.100"
+      "version": "7.0.100",
+      "installUsingApt": false
     }
   }
 }
diff --git a/DisCatSharp.CommandsNext/CommandsNextExtension.cs b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
index 717168ad7..a914f0332 100644
--- a/DisCatSharp.CommandsNext/CommandsNextExtension.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
@@ -1,1086 +1,1084 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Builders;
 using DisCatSharp.CommandsNext.Converters;
 using DisCatSharp.CommandsNext.Entities;
 using DisCatSharp.CommandsNext.Exceptions;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.CommandsNext;
 
 /// <summary>
 /// This is the class which handles command registration, management, and execution.
 /// </summary>
 public class CommandsNextExtension : BaseExtension
 {
 	/// <summary>
 	/// Gets the config.
 	/// </summary>
 	private readonly CommandsNextConfiguration _config;
 
 	/// <summary>
 	/// Gets the help formatter.
 	/// </summary>
 	private readonly HelpFormatterFactory _helpFormatter;
 
 	/// <summary>
 	/// Gets the convert generic.
 	/// </summary>
 	private readonly MethodInfo _convertGeneric;
 
 	/// <summary>
 	/// Gets the user friendly type names.
 	/// </summary>
 	private readonly Dictionary<Type, string> _userFriendlyTypeNames;
 	/// <summary>
 	/// Gets the argument converters.
 	/// </summary>
 	internal Dictionary<Type, IArgumentConverter> ArgumentConverters { get; }
 
 	/// <summary>
 	/// Gets the service provider this CommandsNext module was configured with.
 	/// </summary>
 	public IServiceProvider Services
 		=> this._config.ServiceProvider;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="CommandsNextExtension"/> class.
 	/// </summary>
 	/// <param name="cfg">The cfg.</param>
 	internal CommandsNextExtension(CommandsNextConfiguration cfg)
 	{
 		this._config = new CommandsNextConfiguration(cfg);
 		this._topLevelCommands = new Dictionary<string, Command>();
 		this._registeredCommandsLazy = new Lazy<IReadOnlyDictionary<string, Command>>(() => new ReadOnlyDictionary<string, Command>(this._topLevelCommands));
 		this._helpFormatter = new HelpFormatterFactory();
 		this._helpFormatter.SetFormatterType<DefaultHelpFormatter>();
 
 		this.ArgumentConverters = new Dictionary<Type, IArgumentConverter>
 		{
 			[typeof(string)] = new StringConverter(),
 			[typeof(bool)] = new BoolConverter(),
 			[typeof(sbyte)] = new Int8Converter(),
 			[typeof(byte)] = new Uint8Converter(),
 			[typeof(short)] = new Int16Converter(),
 			[typeof(ushort)] = new Uint16Converter(),
 			[typeof(int)] = new Int32Converter(),
 			[typeof(uint)] = new Uint32Converter(),
 			[typeof(long)] = new Int64Converter(),
 			[typeof(ulong)] = new Uint64Converter(),
 			[typeof(float)] = new Float32Converter(),
 			[typeof(double)] = new Float64Converter(),
 			[typeof(decimal)] = new Float128Converter(),
 			[typeof(DateTime)] = new DateTimeConverter(),
 			[typeof(DateTimeOffset)] = new DateTimeOffsetConverter(),
 			[typeof(TimeSpan)] = new TimeSpanConverter(),
 			[typeof(Uri)] = new UriConverter(),
 			[typeof(DiscordUser)] = new DiscordUserConverter(),
 			[typeof(DiscordMember)] = new DiscordMemberConverter(),
 			[typeof(DiscordRole)] = new DiscordRoleConverter(),
 			[typeof(DiscordChannel)] = new DiscordChannelConverter(),
 			[typeof(DiscordGuild)] = new DiscordGuildConverter(),
 			[typeof(DiscordMessage)] = new DiscordMessageConverter(),
 			[typeof(DiscordEmoji)] = new DiscordEmojiConverter(),
 			[typeof(DiscordThreadChannel)] = new DiscordThreadChannelConverter(),
 			[typeof(DiscordInvite)] = new DiscordInviteConverter(),
 			[typeof(DiscordColor)] = new DiscordColorConverter(),
 			[typeof(DiscordScheduledEvent)] = new DiscordScheduledEventConverter(),
 		};
 
 		this._userFriendlyTypeNames = new Dictionary<Type, string>()
 		{
 			[typeof(string)] = "string",
 			[typeof(bool)] = "boolean",
 			[typeof(sbyte)] = "signed byte",
 			[typeof(byte)] = "byte",
 			[typeof(short)] = "short",
 			[typeof(ushort)] = "unsigned short",
 			[typeof(int)] = "int",
 			[typeof(uint)] = "unsigned int",
 			[typeof(long)] = "long",
 			[typeof(ulong)] = "unsigned long",
 			[typeof(float)] = "float",
 			[typeof(double)] = "double",
 			[typeof(decimal)] = "decimal",
 			[typeof(DateTime)] = "date and time",
 			[typeof(DateTimeOffset)] = "date and time",
 			[typeof(TimeSpan)] = "time span",
 			[typeof(Uri)] = "URL",
 			[typeof(DiscordUser)] = "user",
 			[typeof(DiscordMember)] = "member",
 			[typeof(DiscordRole)] = "role",
 			[typeof(DiscordChannel)] = "channel",
 			[typeof(DiscordGuild)] = "guild",
 			[typeof(DiscordMessage)] = "message",
 			[typeof(DiscordEmoji)] = "emoji",
 			[typeof(DiscordThreadChannel)] = "thread",
 			[typeof(DiscordInvite)] = "invite",
 			[typeof(DiscordColor)] = "color",
 			[typeof(DiscordScheduledEvent)] = "event"
 		};
 
 		foreach (var xt in this.ArgumentConverters.Keys.ToArray())
 		{
 			var xti = xt.GetTypeInfo();
 			if (!xti.IsValueType)
 				continue;
 
 			var xcvt = typeof(NullableConverter<>).MakeGenericType(xt);
 			var xnt = typeof(Nullable<>).MakeGenericType(xt);
 			if (this.ArgumentConverters.ContainsKey(xcvt))
 				continue;
 
 			var xcv = Activator.CreateInstance(xcvt) as IArgumentConverter;
 			this.ArgumentConverters[xnt] = xcv;
 			this._userFriendlyTypeNames[xnt] = this._userFriendlyTypeNames[xt];
 		}
 
 		var t = this.GetType();
 		var ms = t.GetTypeInfo().DeclaredMethods;
 		var m = ms.FirstOrDefault(xm => xm.Name == "ConvertArgumentToObj" && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPrivate);
 		this._convertGeneric = m;
 	}
 
 	/// <summary>
 	/// Sets the help formatter to use with the default help command.
 	/// </summary>
 	/// <typeparam name="T">Type of the formatter to use.</typeparam>
 	public void SetHelpFormatter<T>() where T : BaseHelpFormatter => this._helpFormatter.SetFormatterType<T>();
 
 	#region DiscordClient Registration
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 	/// <exception cref="InvalidOperationException"/>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this._executed = new AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs>("COMMAND_EXECUTED", TimeSpan.Zero, this.Client.EventErrorHandler);
 		this._error = new AsyncEvent<CommandsNextExtension, CommandErrorEventArgs>("COMMAND_ERRORED", TimeSpan.Zero, this.Client.EventErrorHandler);
 
 		if (this._config.UseDefaultCommandHandler)
 			this.Client.MessageCreated += this.HandleCommandsAsync;
 		else
 			this.Client.Logger.LogWarning(CommandsNextEvents.Misc, "Not attaching default command handler - if this is intentional, you can ignore this message");
 
 		if (this._config.EnableDefaultHelp)
 		{
 			this.RegisterCommands(typeof(DefaultHelpModule), null, null, out var tcmds);
 
 			if (this._config.DefaultHelpChecks != null)
 			{
 				var checks = this._config.DefaultHelpChecks.ToArray();
 
 				foreach (var cb in tcmds)
 					cb.WithExecutionChecks(checks);
 			}
 
 			if (tcmds != null)
 				foreach (var xc in tcmds)
 					this.AddToCommandDictionary(xc.Build(null));
 		}
 
 	}
 	#endregion
 
 	#region Command Handling
 	/// <summary>
 	/// Handles the commands async.
 	/// </summary>
 	/// <param name="sender">The sender.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private async Task HandleCommandsAsync(DiscordClient sender, MessageCreateEventArgs e)
 	{
 		if (e.Author.IsBot) // bad bot
 			return;
 
 		if (!this._config.EnableDms && e.Channel.IsPrivate)
 			return;
 
 		var mpos = -1;
 		if (this._config.EnableMentionPrefix)
 			mpos = e.Message.GetMentionPrefixLength(this.Client.CurrentUser);
 
 		if (this._config.StringPrefixes?.Any() == true)
 			foreach (var pfix in this._config.StringPrefixes)
 				if (mpos == -1 && !string.IsNullOrWhiteSpace(pfix))
 					mpos = e.Message.GetStringPrefixLength(pfix, this._config.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
 
 		if (mpos == -1 && this._config.PrefixResolver != null)
 			mpos = await this._config.PrefixResolver(e.Message).ConfigureAwait(false);
 
 		if (mpos == -1)
 			return;
 
 		var pfx = e.Message.Content[..mpos];
 		var cnt = e.Message.Content[mpos..];
 
 		var __ = 0;
 		var fname = cnt.ExtractNextArgument(ref __);
 
 		var cmd = this.FindCommand(cnt, out var args);
 		var ctx = this.CreateContext(e.Message, pfx, cmd, args);
 		if (cmd == null)
 		{
 			await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = ctx, Exception = new CommandNotFoundException(fname) }).ConfigureAwait(false);
 			return;
 		}
 
 		_ = Task.Run(async () => await this.ExecuteCommandAsync(ctx).ConfigureAwait(false));
 	}
 
 	/// <summary>
 	/// Finds a specified command by its qualified name, then separates arguments.
 	/// </summary>
 	/// <param name="commandString">Qualified name of the command, optionally with arguments.</param>
 	/// <param name="rawArguments">Separated arguments.</param>
 	/// <returns>Found command or null if none was found.</returns>
 	public Command FindCommand(string commandString, out string rawArguments)
 	{
 		rawArguments = null;
 
 		var ignoreCase = !this._config.CaseSensitive;
 		var pos = 0;
 		var next = commandString.ExtractNextArgument(ref pos);
 		if (next == null)
 			return null;
 
 		if (!this.RegisteredCommands.TryGetValue(next, out var cmd))
 		{
 			if (!ignoreCase)
 				return null;
 
 			next = next.ToLowerInvariant();
 			var cmdKvp = this.RegisteredCommands.FirstOrDefault(x => x.Key.ToLowerInvariant() == next);
 			if (cmdKvp.Value == null)
 				return null;
 
 			cmd = cmdKvp.Value;
 		}
 
 		if (cmd is not CommandGroup)
 		{
 			rawArguments = commandString[pos..].Trim();
 			return cmd;
 		}
 
 		while (cmd is CommandGroup)
 		{
 			var cm2 = cmd as CommandGroup;
 			var oldPos = pos;
 			next = commandString.ExtractNextArgument(ref pos);
 			if (next == null)
 				break;
 
 			if (ignoreCase)
 			{
 				next = next.ToLowerInvariant();
 				cmd = cm2.Children.FirstOrDefault(x => x.Name.ToLowerInvariant() == next || x.Aliases?.Any(xx => xx.ToLowerInvariant() == next) == true);
 			}
 			else
 			{
 				cmd = cm2.Children.FirstOrDefault(x => x.Name == next || x.Aliases?.Contains(next) == true);
 			}
 
 			if (cmd == null)
 			{
 				cmd = cm2;
 				pos = oldPos;
 				break;
 			}
 		}
 
 		rawArguments = commandString[pos..].Trim();
 		return cmd;
 	}
 
 	/// <summary>
 	/// Creates a command execution context from specified arguments.
 	/// </summary>
 	/// <param name="msg">Message to use for context.</param>
 	/// <param name="prefix">Command prefix, used to execute commands.</param>
 	/// <param name="cmd">Command to execute.</param>
 	/// <param name="rawArguments">Raw arguments to pass to command.</param>
 	/// <returns>Created command execution context.</returns>
 	public CommandContext CreateContext(DiscordMessage msg, string prefix, Command cmd, string rawArguments = null)
 	{
 		var ctx = new CommandContext
 		{
 			Client = this.Client,
 			Command = cmd,
 			Message = msg,
 			Config = this._config,
 			RawArgumentString = rawArguments ?? "",
 			Prefix = prefix,
 			CommandsNext = this,
 			Services = this.Services
 		};
 
 		if (cmd != null && (cmd.Module is TransientCommandModule || cmd.Module == null))
 		{
 			var scope = ctx.Services.CreateScope();
 			ctx.ServiceScopeContext = new CommandContext.ServiceContext(ctx.Services, scope);
 			ctx.Services = scope.ServiceProvider;
 		}
 
 		return ctx;
 	}
 
 	/// <summary>
 	/// Executes specified command from given context.
 	/// </summary>
 	/// <param name="ctx">Context to execute command from.</param>
 	/// <returns></returns>
 	public async Task ExecuteCommandAsync(CommandContext ctx)
 	{
 		try
 		{
 			var cmd = ctx.Command;
 			await this.RunAllChecksAsync(cmd, ctx).ConfigureAwait(false);
 
 			var res = await cmd.ExecuteAsync(ctx).ConfigureAwait(false);
 
 			if (res.IsSuccessful)
 				await this._executed.InvokeAsync(this, new CommandExecutionEventArgs(this.Client.ServiceProvider) { Context = res.Context }).ConfigureAwait(false);
 			else
 				await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = res.Context, Exception = res.Exception }).ConfigureAwait(false);
 		}
 		catch (Exception ex)
 		{
 			await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = ctx, Exception = ex }).ConfigureAwait(false);
 		}
 		finally
 		{
 			if (ctx.ServiceScopeContext.IsInitialized)
 				ctx.ServiceScopeContext.Dispose();
 		}
 	}
 
 	/// <summary>
 	/// Runs the all checks async.
 	/// </summary>
 	/// <param name="cmd">The cmd.</param>
 	/// <param name="ctx">The ctx.</param>
 	/// <returns>A Task.</returns>
 	private async Task RunAllChecksAsync(Command cmd, CommandContext ctx)
 	{
 		if (cmd.Parent != null)
 			await this.RunAllChecksAsync(cmd.Parent, ctx).ConfigureAwait(false);
 
 		var fchecks = await cmd.RunChecksAsync(ctx, false).ConfigureAwait(false);
 		if (fchecks.Any())
 			throw new ChecksFailedException(cmd, ctx, fchecks);
 	}
 	#endregion
 
 	#region Command Registration
 	/// <summary>
 	/// Gets a dictionary of registered top-level commands.
 	/// </summary>
 	public IReadOnlyDictionary<string, Command> RegisteredCommands
 		=> this._registeredCommandsLazy.Value;
 
 	/// <summary>
 	/// Gets or sets the top level commands.
 	/// </summary>
 	private readonly Dictionary<string, Command> _topLevelCommands;
 	private readonly Lazy<IReadOnlyDictionary<string, Command>> _registeredCommandsLazy;
 
 	/// <summary>
 	/// Registers all commands from a given assembly. The command classes need to be public to be considered for registration.
 	/// </summary>
 	/// <param name="assembly">Assembly to register commands from.</param>
 	public void RegisterCommands(Assembly assembly)
 	{
 		var types = assembly.ExportedTypes.Where(xt =>
 		{
 			var xti = xt.GetTypeInfo();
 			return xti.IsModuleCandidateType() && !xti.IsNested;
 		});
 		foreach (var xt in types)
 			this.RegisterCommands(xt);
 	}
 
 	/// <summary>
 	/// Registers all commands from a given command class.
 	/// </summary>
 	/// <typeparam name="T">Class which holds commands to register.</typeparam>
 	public void RegisterCommands<T>() where T : BaseCommandModule
 	{
 		var t = typeof(T);
 		this.RegisterCommands(t);
 	}
 
 	/// <summary>
 	/// Registers all commands from a given command class.
 	/// </summary>
 	/// <param name="t">Type of the class which holds commands to register.</param>
 	public void RegisterCommands(Type t)
 	{
 		if (t == null)
 			throw new ArgumentNullException(nameof(t), "Type cannot be null.");
 
 		if (!t.IsModuleCandidateType())
 			throw new ArgumentNullException(nameof(t), "Type must be a class, which cannot be abstract or static.");
 
 		this.RegisterCommands(t, null, null, out var tempCommands);
 
 		if (tempCommands != null)
 			foreach (var command in tempCommands)
 				this.AddToCommandDictionary(command.Build(null));
 	}
 
 	/// <summary>
 	/// Registers the commands.
 	/// </summary>
 	/// <param name="t">The type.</param>
 	/// <param name="currentParent">The current parent.</param>
 	/// <param name="inheritedChecks">The inherited checks.</param>
 	/// <param name="foundCommands">The found commands.</param>
 	private void RegisterCommands(Type t, CommandGroupBuilder currentParent, IEnumerable<CheckBaseAttribute> inheritedChecks, out List<CommandBuilder> foundCommands)
 	{
 		var ti = t.GetTypeInfo();
 
 		var lifespan = ti.GetCustomAttribute<ModuleLifespanAttribute>();
 		var moduleLifespan = lifespan != null ? lifespan.Lifespan : ModuleLifespan.Singleton;
 
 		var module = new CommandModuleBuilder()
 			.WithType(t)
 			.WithLifespan(moduleLifespan)
 			.Build(this.Services);
 
 		// restrict parent lifespan to more or equally restrictive
 		if (currentParent?.Module is TransientCommandModule && moduleLifespan != ModuleLifespan.Transient)
 			throw new InvalidOperationException("In a transient module, child modules can only be transient.");
 
 		// check if we are anything
 		var groupBuilder = new CommandGroupBuilder(module);
 		var isModule = false;
 		var moduleAttributes = ti.GetCustomAttributes();
 		var moduleHidden = false;
 		var moduleChecks = new List<CheckBaseAttribute>();
 
 		foreach (var xa in moduleAttributes)
 		{
 			switch (xa)
 			{
 				case GroupAttribute g:
 					isModule = true;
 					var moduleName = g.Name;
 					if (moduleName == null)
 					{
 						moduleName = ti.Name;
 
 						if (moduleName.EndsWith("Group") && moduleName != "Group")
 							moduleName = moduleName[0..^5];
 						else if (moduleName.EndsWith("Module") && moduleName != "Module")
 							moduleName = moduleName[0..^6];
 						else if (moduleName.EndsWith("Commands") && moduleName != "Commands")
 							moduleName = moduleName[0..^8];
 					}
 
 					if (!this._config.CaseSensitive)
 						moduleName = moduleName.ToLowerInvariant();
 
 					groupBuilder.WithName(moduleName);
 
 					if (inheritedChecks != null)
 						foreach (var chk in inheritedChecks)
 							groupBuilder.WithExecutionCheck(chk);
 
 					foreach (var mi in ti.DeclaredMethods.Where(x => x.IsCommandCandidate(out _) && x.GetCustomAttribute<GroupCommandAttribute>() != null))
 						groupBuilder.WithOverload(new CommandOverloadBuilder(mi));
 					break;
 
 				case AliasesAttribute a:
 					foreach (var xalias in a.Aliases)
 						groupBuilder.WithAlias(this._config.CaseSensitive ? xalias : xalias.ToLowerInvariant());
 					break;
 
 				case HiddenAttribute h:
 					groupBuilder.WithHiddenStatus(true);
 					moduleHidden = true;
 					break;
 
 				case DescriptionAttribute d:
 					groupBuilder.WithDescription(d.Description);
 					break;
 
 				case CheckBaseAttribute c:
 					moduleChecks.Add(c);
 					groupBuilder.WithExecutionCheck(c);
 					break;
 
 				default:
 					groupBuilder.WithCustomAttribute(xa);
 					break;
 			}
 		}
 
 		if (!isModule)
 		{
 			groupBuilder = null;
 			if (inheritedChecks != null)
 				moduleChecks.AddRange(inheritedChecks);
 		}
 
 		// candidate methods
 		var methods = ti.DeclaredMethods;
 		var commands = new List<CommandBuilder>();
 		var commandBuilders = new Dictionary<string, CommandBuilder>();
 		foreach (var m in methods)
 		{
 			if (!m.IsCommandCandidate(out _))
 				continue;
 
 			var attrs = m.GetCustomAttributes();
 			if (attrs.FirstOrDefault(xa => xa is CommandAttribute) is not CommandAttribute cattr)
 				continue;
 
 			var commandName = cattr.Name;
 			if (commandName == null)
 			{
 				commandName = m.Name;
 				if (commandName.EndsWith("Async") && commandName != "Async")
 					commandName = commandName[0..^5];
 			}
 
 			if (!this._config.CaseSensitive)
 				commandName = commandName.ToLowerInvariant();
 
 			if (!commandBuilders.TryGetValue(commandName, out var commandBuilder))
 			{
 				commandBuilders.Add(commandName, commandBuilder = new CommandBuilder(module).WithName(commandName));
 
 				if (!isModule)
 					if (currentParent != null)
 						currentParent.WithChild(commandBuilder);
 					else
 						commands.Add(commandBuilder);
 				else
 					groupBuilder.WithChild(commandBuilder);
 			}
 
 			commandBuilder.WithOverload(new CommandOverloadBuilder(m));
 
 			if (!isModule && moduleChecks.Any())
 				foreach (var chk in moduleChecks)
 					commandBuilder.WithExecutionCheck(chk);
 
 			foreach (var xa in attrs)
 			{
 				switch (xa)
 				{
 					case AliasesAttribute a:
 						foreach (var xalias in a.Aliases)
 							commandBuilder.WithAlias(this._config.CaseSensitive ? xalias : xalias.ToLowerInvariant());
 						break;
 
 					case CheckBaseAttribute p:
 						commandBuilder.WithExecutionCheck(p);
 						break;
 
 					case DescriptionAttribute d:
 						commandBuilder.WithDescription(d.Description);
 						break;
 
 					case HiddenAttribute h:
 						commandBuilder.WithHiddenStatus(true);
 						break;
 
 					default:
 						commandBuilder.WithCustomAttribute(xa);
 						break;
 				}
 			}
 
 			if (!isModule && moduleHidden)
 				commandBuilder.WithHiddenStatus(true);
 		}
 
 		// candidate types
 		var types = ti.DeclaredNestedTypes
 			.Where(xt => xt.IsModuleCandidateType() && xt.DeclaredConstructors.Any(xc => xc.IsPublic));
 		foreach (var type in types)
 		{
 			this.RegisterCommands(type.AsType(),
 				groupBuilder,
 				!isModule ? moduleChecks : null,
 				out var tempCommands);
 
 			if (isModule)
 				foreach (var chk in moduleChecks)
 					groupBuilder.WithExecutionCheck(chk);
 
 			if (isModule && tempCommands != null)
 				foreach (var xtcmd in tempCommands)
 					groupBuilder.WithChild(xtcmd);
 			else if (tempCommands != null)
 				commands.AddRange(tempCommands);
 		}
 
 		if (isModule && currentParent == null)
 			commands.Add(groupBuilder);
 		else if (isModule)
 			currentParent.WithChild(groupBuilder);
 		foundCommands = commands;
 	}
 
 	/// <summary>
 	/// Builds and registers all supplied commands.
 	/// </summary>
 	/// <param name="cmds">Commands to build and register.</param>
 	public void RegisterCommands(params CommandBuilder[] cmds)
 	{
 		foreach (var cmd in cmds)
 			this.AddToCommandDictionary(cmd.Build(null));
 	}
 
 	/// <summary>
 	/// Unregister specified commands from CommandsNext.
 	/// </summary>
 	/// <param name="cmds">Commands to unregister.</param>
 	public void UnregisterCommands(params Command[] cmds)
 	{
 		if (cmds.Any(x => x.Parent != null))
 			throw new InvalidOperationException("Cannot unregister nested commands.");
 
 		var keys = this.RegisteredCommands.Where(x => cmds.Contains(x.Value)).Select(x => x.Key).ToList();
 		foreach (var key in keys)
 			this._topLevelCommands.Remove(key);
 	}
 
 	/// <summary>
 	/// Adds the to command dictionary.
 	/// </summary>
 	/// <param name="cmd">The cmd.</param>
 	private void AddToCommandDictionary(Command cmd)
 	{
 		if (cmd.Parent != null)
 			return;
 
 		if (this._topLevelCommands.ContainsKey(cmd.Name) || (cmd.Aliases != null && cmd.Aliases.Any(xs => this._topLevelCommands.ContainsKey(xs))))
 			throw new DuplicateCommandException(cmd.QualifiedName);
 
 		this._topLevelCommands[cmd.Name] = cmd;
 		if (cmd.Aliases != null)
 			foreach (var xs in cmd.Aliases)
 				this._topLevelCommands[xs] = cmd;
 	}
 	#endregion
 
 	#region Default Help
 	/// <summary>
 	/// Represents the default help module.
 	/// </summary>
 	[ModuleLifespan(ModuleLifespan.Transient)]
 	public class DefaultHelpModule : BaseCommandModule
 	{
 		/// <summary>
 		/// Defaults the help async.
 		/// </summary>
 		/// <param name="ctx">The ctx.</param>
 		/// <param name="command">The command.</param>
 		/// <returns>A Task.</returns>
 		[Command("help"), Description("Displays command help.")]
 		public async Task DefaultHelpAsync(CommandContext ctx, [Description("Command to provide help for.")] params string[] command)
 		{
 			var topLevel = ctx.CommandsNext._topLevelCommands.Values.Distinct();
 			var helpBuilder = ctx.CommandsNext._helpFormatter.Create(ctx);
 
 			if (command != null && command.Any())
 			{
 				Command cmd = null;
 				var searchIn = topLevel;
 				foreach (var c in command)
 				{
 					if (searchIn == null)
 					{
 						cmd = null;
 						break;
 					}
 
 					cmd = ctx.Config.CaseSensitive
 						? searchIn.FirstOrDefault(xc => xc.Name == c || (xc.Aliases != null && xc.Aliases.Contains(c)))
 						: searchIn.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == c.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(c.ToLowerInvariant())));
 
 					if (cmd == null)
 						break;
 
 					var failedChecks = await cmd.RunChecksAsync(ctx, true).ConfigureAwait(false);
 					if (failedChecks.Any())
 						throw new ChecksFailedException(cmd, ctx, failedChecks);
 
 					searchIn = cmd is CommandGroup ? (cmd as CommandGroup).Children : null;
 				}
 
 				if (cmd == null)
 					throw new CommandNotFoundException(string.Join(" ", command));
 
 				helpBuilder.WithCommand(cmd);
 
 				if (cmd is CommandGroup group)
 				{
 					var commandsToSearch = group.Children.Where(xc => !xc.IsHidden);
 					var eligibleCommands = new List<Command>();
 					foreach (var candidateCommand in commandsToSearch)
 					{
 						if (candidateCommand.ExecutionChecks == null || !candidateCommand.ExecutionChecks.Any())
 						{
 							eligibleCommands.Add(candidateCommand);
 							continue;
 						}
 
 						var candidateFailedChecks = await candidateCommand.RunChecksAsync(ctx, true).ConfigureAwait(false);
 						if (!candidateFailedChecks.Any())
 							eligibleCommands.Add(candidateCommand);
 					}
 
 					if (eligibleCommands.Any())
 						helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
 				}
 			}
 			else
 			{
 				var commandsToSearch = topLevel.Where(xc => !xc.IsHidden);
 				var eligibleCommands = new List<Command>();
 				foreach (var sc in commandsToSearch)
 				{
 					if (sc.ExecutionChecks == null || !sc.ExecutionChecks.Any())
 					{
 						eligibleCommands.Add(sc);
 						continue;
 					}
 
 					var candidateFailedChecks = await sc.RunChecksAsync(ctx, true).ConfigureAwait(false);
 					if (!candidateFailedChecks.Any())
 						eligibleCommands.Add(sc);
 				}
 
 				if (eligibleCommands.Any())
 					helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
 			}
 
 			var helpMessage = helpBuilder.Build();
 
 			var builder = new DiscordMessageBuilder().WithContent(helpMessage.Content).WithEmbed(helpMessage.Embed);
 
 			if (!ctx.Config.DmHelp || ctx.Channel is DiscordDmChannel || ctx.Guild == null)
 				await ctx.RespondAsync(builder).ConfigureAwait(false);
 			else
 				await ctx.Member.SendMessageAsync(builder).ConfigureAwait(false);
 
 		}
 	}
 	#endregion
 
 	#region Sudo
 	/// <summary>
 	/// Creates a fake command context to execute commands with.
 	/// </summary>
 	/// <param name="actor">The user or member to use as message author.</param>
 	/// <param name="channel">The channel the message is supposed to appear from.</param>
 	/// <param name="messageContents">Contents of the message.</param>
 	/// <param name="prefix">Command prefix, used to execute commands.</param>
 	/// <param name="cmd">Command to execute.</param>
 	/// <param name="rawArguments">Raw arguments to pass to command.</param>
 	/// <returns>Created fake context.</returns>
 	public CommandContext CreateFakeContext(DiscordUser actor, DiscordChannel channel, string messageContents, string prefix, Command cmd, string rawArguments = null)
 	{
 		var epoch = new DateTimeOffset(2015, 1, 1, 0, 0, 0, TimeSpan.Zero);
 		var now = DateTimeOffset.UtcNow;
 		var timeSpan = (ulong)(now - epoch).TotalMilliseconds;
 
 		// create fake message
 		var msg = new DiscordMessage
 		{
 			Discord = this.Client,
 			Author = actor,
 			ChannelId = channel.Id,
 			Content = messageContents,
 			Id = timeSpan << 22,
 			Pinned = false,
 			MentionEveryone = messageContents.Contains("@everyone"),
 			IsTts = false,
 			AttachmentsInternal = new List<DiscordAttachment>(),
 			EmbedsInternal = new List<DiscordEmbed>(),
 			TimestampRaw = now.ToString("yyyy-MM-ddTHH:mm:sszzz"),
 			ReactionsInternal = new List<DiscordReaction>()
 		};
 
 		var mentionedUsers = new List<DiscordUser>();
 		var mentionedRoles = msg.Channel.Guild != null ? new List<DiscordRole>() : null;
 		var mentionedChannels = msg.Channel.Guild != null ? new List<DiscordChannel>() : null;
 
 		if (!string.IsNullOrWhiteSpace(msg.Content))
 		{
 			if (msg.Channel.Guild != null)
 			{
 				mentionedUsers = Utilities.GetUserMentions(msg).Select(xid => msg.Channel.Guild.MembersInternal.TryGetValue(xid, out var member) ? member : null).Cast<DiscordUser>().ToList();
 				mentionedRoles = Utilities.GetRoleMentions(msg).Select(xid => msg.Channel.Guild.GetRole(xid)).ToList();
 				mentionedChannels = Utilities.GetChannelMentions(msg).Select(xid => msg.Channel.Guild.GetChannel(xid)).ToList();
 			}
 			else
 			{
 				mentionedUsers = Utilities.GetUserMentions(msg).Select(this.Client.GetCachedOrEmptyUserInternal).ToList();
 			}
 		}
 
 		msg.MentionedUsersInternal = mentionedUsers;
 		msg.MentionedRolesInternal = mentionedRoles;
 		msg.MentionedChannelsInternal = mentionedChannels;
 
 		var ctx = new CommandContext
 		{
 			Client = this.Client,
 			Command = cmd,
 			Message = msg,
 			Config = this._config,
 			RawArgumentString = rawArguments ?? "",
 			Prefix = prefix,
 			CommandsNext = this,
 			Services = this.Services
 		};
 
 		if (cmd != null && (cmd.Module is TransientCommandModule || cmd.Module == null))
 		{
 			var scope = ctx.Services.CreateScope();
 			ctx.ServiceScopeContext = new CommandContext.ServiceContext(ctx.Services, scope);
 			ctx.Services = scope.ServiceProvider;
 		}
 
 		return ctx;
 	}
 	#endregion
 
 	#region Type Conversion
 	/// <summary>
 	/// Converts a string to specified type.
 	/// </summary>
 	/// <typeparam name="T">Type to convert to.</typeparam>
 	/// <param name="value">Value to convert.</param>
 	/// <param name="ctx">Context in which to convert to.</param>
 	/// <returns>Converted object.</returns>
 	public async Task<T> ConvertArgument<T>(string value, CommandContext ctx)
 	{
 		var t = typeof(T);
 		if (!this.ArgumentConverters.ContainsKey(t))
 			throw new ArgumentException("There is no converter specified for given type.", nameof(T));
 
 		if (this.ArgumentConverters[t] is not IArgumentConverter<T> cv)
 			throw new ArgumentException("Invalid converter registered for this type.", nameof(T));
 
 		var cvr = await cv.ConvertAsync(value, ctx).ConfigureAwait(false);
 		return !cvr.HasValue ? throw new ArgumentException("Could not convert specified value to given type.", nameof(value)) : cvr.Value;
 	}
 
 	/// <summary>
 	/// Converts a string to specified type.
 	/// </summary>
 	/// <param name="value">Value to convert.</param>
 	/// <param name="ctx">Context in which to convert to.</param>
 	/// <param name="type">Type to convert to.</param>
 	/// <returns>Converted object.</returns>
 	public async Task<object> ConvertArgument(string value, CommandContext ctx, Type type)
 	{
 		var m = this._convertGeneric.MakeGenericMethod(type);
 		try
 		{
 			return await (m.Invoke(this, new object[] { value, ctx }) as Task<object>).ConfigureAwait(false);
 		}
 		catch (TargetInvocationException ex)
 		{
 			throw ex.InnerException;
 		}
 	}
 
 	/// <summary>
 	/// Registers an argument converter for specified type.
 	/// </summary>
 	/// <typeparam name="T">Type for which to register the converter.</typeparam>
 	/// <param name="converter">Converter to register.</param>
 	public void RegisterConverter<T>(IArgumentConverter<T> converter)
 	{
 		if (converter == null)
 			throw new ArgumentNullException(nameof(converter), "Converter cannot be null.");
 
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
 		this.ArgumentConverters[t] = converter;
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableConverterType = typeof(NullableConverter<>).MakeGenericType(t);
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		if (this.ArgumentConverters.ContainsKey(nullableType))
 			return;
 
 		var nullableConverter = Activator.CreateInstance(nullableConverterType) as IArgumentConverter;
 		this.ArgumentConverters[nullableType] = nullableConverter;
 	}
 
 	/// <summary>
 	/// Unregister an argument converter for specified type.
 	/// </summary>
 	/// <typeparam name="T">Type for which to unregister the converter.</typeparam>
 	public void UnregisterConverter<T>()
 	{
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
-		if (this.ArgumentConverters.ContainsKey(t))
-			this.ArgumentConverters.Remove(t);
+		this.ArgumentConverters.Remove(t);
 
-		if (this._userFriendlyTypeNames.ContainsKey(t))
-			this._userFriendlyTypeNames.Remove(t);
+		this._userFriendlyTypeNames.Remove(t);
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		if (!this.ArgumentConverters.ContainsKey(nullableType))
 			return;
 
 		this.ArgumentConverters.Remove(nullableType);
 		this._userFriendlyTypeNames.Remove(nullableType);
 	}
 
 	/// <summary>
 	/// Registers a user-friendly type name.
 	/// </summary>
 	/// <typeparam name="T">Type to register the name for.</typeparam>
 	/// <param name="value">Name to register.</param>
 	public void RegisterUserFriendlyTypeName<T>(string value)
 	{
 		if (string.IsNullOrWhiteSpace(value))
 			throw new ArgumentNullException(nameof(value), "Name cannot be null or empty.");
 
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
 		if (!this.ArgumentConverters.ContainsKey(t))
 			throw new InvalidOperationException("Cannot register a friendly name for a type which has no associated converter.");
 
 		this._userFriendlyTypeNames[t] = value;
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		this._userFriendlyTypeNames[nullableType] = value;
 	}
 
 	/// <summary>
 	/// Converts a type into user-friendly type name.
 	/// </summary>
 	/// <param name="t">Type to convert.</param>
 	/// <returns>User-friendly type name.</returns>
 	public string GetUserFriendlyTypeName(Type t)
 	{
-		if (this._userFriendlyTypeNames.ContainsKey(t))
-			return this._userFriendlyTypeNames[t];
+		if (this._userFriendlyTypeNames.TryGetValue(t, out var val))
+			return val;
 
 		var ti = t.GetTypeInfo();
 		if (ti.IsGenericTypeDefinition && t.GetGenericTypeDefinition() == typeof(Nullable<>))
 		{
 			var tn = ti.GenericTypeArguments[0];
-			return this._userFriendlyTypeNames.ContainsKey(tn) ? this._userFriendlyTypeNames[tn] : tn.Name;
+			return this._userFriendlyTypeNames.TryGetValue(tn, out var value) ? value : tn.Name;
 		}
 
 		return t.Name;
 	}
 	#endregion
 
 	#region Helpers
 	/// <summary>
 	/// Allows easier interoperability with reflection by turning the <see cref="Task{T}"/> returned by <see cref="ConvertArgument"/>
 	/// into a task containing <see cref="object"/>, using the provided generic type information.
 	/// </summary>
 	private async Task<object> ConvertArgumentToObj<T>(string value, CommandContext ctx)
 		=> await this.ConvertArgument<T>(value, ctx).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets the configuration-specific string comparer. This returns <see cref="StringComparer.Ordinal"/> or <see cref="StringComparer.OrdinalIgnoreCase"/>,
 	/// depending on whether <see cref="CommandsNextConfiguration.CaseSensitive"/> is set to <see langword="true"/> or <see langword="false"/>.
 	/// </summary>
 	/// <returns>A string comparer.</returns>
 	internal IEqualityComparer<string> GetStringComparer()
 		=> this._config.CaseSensitive
 			? StringComparer.Ordinal
 			: StringComparer.OrdinalIgnoreCase;
 	#endregion
 
 	#region Events
 	/// <summary>
 	/// Triggered whenever a command executes successfully.
 	/// </summary>
 	public event AsyncEventHandler<CommandsNextExtension, CommandExecutionEventArgs> CommandExecuted
 	{
 		add => this._executed.Register(value);
 		remove => this._executed.Unregister(value);
 	}
 	private AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs> _executed;
 
 	/// <summary>
 	/// Triggered whenever a command throws an exception during execution.
 	/// </summary>
 	public event AsyncEventHandler<CommandsNextExtension, CommandErrorEventArgs> CommandErrored
 	{
 		add => this._error.Register(value);
 		remove => this._error.Unregister(value);
 	}
 	private AsyncEvent<CommandsNextExtension, CommandErrorEventArgs> _error;
 
 	/// <summary>
 	/// Fires when a command gets executed.
 	/// </summary>
 	/// <param name="e">The command execution event arguments.</param>
 	private Task OnCommandExecuted(CommandExecutionEventArgs e)
 		=> this._executed.InvokeAsync(this, e);
 
 	/// <summary>
 	/// Fires when a command fails.
 	/// </summary>
 	/// <param name="e">The command error event arguments.</param>
 	private Task OnCommandErrored(CommandErrorEventArgs e)
 		=> this._error.InvokeAsync(this, e);
 	#endregion
 }
diff --git a/DisCatSharp.CommandsNext/Converters/ArgumentBindingResult.cs b/DisCatSharp.CommandsNext/Converters/ArgumentBindingResult.cs
index 0f898cfa8..cfbec2be1 100644
--- a/DisCatSharp.CommandsNext/Converters/ArgumentBindingResult.cs
+++ b/DisCatSharp.CommandsNext/Converters/ArgumentBindingResult.cs
@@ -1,74 +1,74 @@
 // 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;
 
 namespace DisCatSharp.CommandsNext.Converters;
 
 /// <summary>
 /// Represents a argument binding result.
 /// </summary>
-public struct ArgumentBindingResult
+public readonly struct ArgumentBindingResult
 {
 	/// <summary>
 	/// Gets a value indicating whether the binding is successful.
 	/// </summary>
 	public bool IsSuccessful { get; }
 	/// <summary>
 	/// Gets the converted.
 	/// </summary>
 	public object[] Converted { get; }
 	/// <summary>
 	/// Gets the raw.
 	/// </summary>
 	public IReadOnlyList<string> Raw { get; }
 	/// <summary>
 	/// Gets the reason.
 	/// </summary>
 	public Exception Reason { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ArgumentBindingResult"/> class.
 	/// </summary>
 	/// <param name="converted">The converted.</param>
 	/// <param name="raw">The raw.</param>
 	public ArgumentBindingResult(object[] converted, IReadOnlyList<string> raw)
 	{
 		this.IsSuccessful = true;
 		this.Reason = null;
 		this.Converted = converted;
 		this.Raw = raw;
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ArgumentBindingResult"/> class.
 	/// </summary>
 	/// <param name="ex">The ex.</param>
 	public ArgumentBindingResult(Exception ex)
 	{
 		this.IsSuccessful = false;
 		this.Reason = ex;
 		this.Converted = null;
 		this.Raw = null;
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Entities/CommandHelpMessage.cs b/DisCatSharp.CommandsNext/Entities/CommandHelpMessage.cs
index cd4e26d96..597ccfaf2 100644
--- a/DisCatSharp.CommandsNext/Entities/CommandHelpMessage.cs
+++ b/DisCatSharp.CommandsNext/Entities/CommandHelpMessage.cs
@@ -1,52 +1,52 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Entities;
 
 /// <summary>
 /// Represents a formatted help message.
 /// </summary>
-public struct CommandHelpMessage
+public readonly struct CommandHelpMessage
 {
 	/// <summary>
 	/// Gets the contents of the help message.
 	/// </summary>
 	public string Content { get; }
 
 	/// <summary>
 	/// Gets the embed attached to the help message.
 	/// </summary>
 	public DiscordEmbed Embed { get; }
 
 	/// <summary>
 	/// Creates a new instance of a help message.
 	/// </summary>
 	/// <param name="content">Contents of the message.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	public CommandHelpMessage(string content = null, DiscordEmbed embed = null)
 	{
 		this.Content = content;
 		this.Embed = embed;
 	}
 }
diff --git a/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs b/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs
index 69cba3138..3fa4d24cf 100644
--- a/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs
+++ b/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs
@@ -1,207 +1,207 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.CommandsNext;
 
 /// <summary>
 /// Represents a context in which a command is executed.
 /// </summary>
 public sealed class CommandContext
 {
 	/// <summary>
 	/// Gets the client which received the message.
 	/// </summary>
 	public DiscordClient Client { get; internal set; }
 
 	/// <summary>
 	/// Gets the message that triggered the execution.
 	/// </summary>
 	public DiscordMessage Message { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel in which the execution was triggered,
 	/// </summary>
 	public DiscordChannel Channel
 		=> this.Message.Channel;
 
 	/// <summary>
 	/// Gets the guild in which the execution was triggered. This property is null for commands sent over direct messages.
 	/// </summary>
 	public DiscordGuild Guild
 		=> this.Channel.Guild;
 
 	/// <summary>
 	/// Gets the user who triggered the execution.
 	/// </summary>
 	public DiscordUser User
 		=> this.Message.Author;
 
 	/// <summary>
 	/// Gets the member who triggered the execution. This property is null for commands sent over direct messages.
 	/// </summary>
 	public DiscordMember Member
 		=> this._lazyMember.Value;
 
 	private readonly Lazy<DiscordMember> _lazyMember;
 
 	/// <summary>
 	/// Gets the CommandsNext service instance that handled this command.
 	/// </summary>
 	public CommandsNextExtension CommandsNext { get; internal set; }
 
 	/// <summary>
 	/// Gets the service provider for this CNext instance.
 	/// </summary>
 	public IServiceProvider Services { get; internal set; }
 
 	/// <summary>
 	/// Gets the command that is being executed.
 	/// </summary>
 	public Command Command { get; internal set; }
 
 	/// <summary>
 	/// Gets the overload of the command that is being executed.
 	/// </summary>
 	public CommandOverload Overload { get; internal set; }
 
 	/// <summary>
 	/// Gets the list of raw arguments passed to the command.
 	/// </summary>
 	public IReadOnlyList<string> RawArguments { get; internal set; }
 
 	/// <summary>
 	/// Gets the raw string from which the arguments were extracted.
 	/// </summary>
 	public string RawArgumentString { get; internal set; }
 
 	/// <summary>
 	/// Gets the prefix used to invoke the command.
 	/// </summary>
 	public string Prefix { get; internal set; }
 
 	/// <summary>
 	/// Gets or sets the config.
 	/// </summary>
 	internal CommandsNextConfiguration Config { get; set; }
 
 	/// <summary>
 	/// Gets or sets the service scope context.
 	/// </summary>
 	internal ServiceContext ServiceScopeContext { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="CommandContext"/> class.
 	/// </summary>
 	internal CommandContext()
 	{
 		this._lazyMember = new Lazy<DiscordMember>(() => this.Guild != null && this.Guild.Members.TryGetValue(this.User.Id, out var member) ? member : this.Guild?.GetMemberAsync(this.User.Id).ConfigureAwait(false).GetAwaiter().GetResult());
 	}
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="content">Message to respond with.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(string content)
 		=> this.Message.RespondAsync(content);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="embed">Embed to attach.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
 		=> this.Message.RespondAsync(embed);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="content">Message to respond with.</param>
 	/// <param name="embed">Embed to attach.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
 		=> this.Message.RespondAsync(content, embed);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="builder">The Discord Message builder.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
 		=> this.Message.RespondAsync(builder);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="action">The Discord Message builder.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
 		=> this.Message.RespondAsync(action);
 
 	/// <summary>
 	/// Triggers typing in the channel containing the message that triggered the command.
 	/// </summary>
 	/// <returns></returns>
 	public Task TriggerTypingAsync()
 		=> this.Channel.TriggerTypingAsync();
 
-	internal struct ServiceContext : IDisposable
+	internal readonly struct ServiceContext : IDisposable
 	{
 		/// <summary>
 		/// Gets the provider.
 		/// </summary>
 		public IServiceProvider Provider { get; }
 		/// <summary>
 		/// Gets the scope.
 		/// </summary>
 		public IServiceScope Scope { get; }
 		/// <summary>
 		/// Gets a value indicating whether is initialized.
 		/// </summary>
 		public bool IsInitialized { get; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ServiceContext"/> class.
 		/// </summary>
 		/// <param name="services">The services.</param>
 		/// <param name="scope">The scope.</param>
 		public ServiceContext(IServiceProvider services, IServiceScope scope)
 		{
 			this.Provider = services;
 			this.Scope = scope;
 			this.IsInitialized = true;
 		}
 
 		/// <summary>
 		/// Disposes the command context.
 		/// </summary>
 		public void Dispose() => this.Scope?.Dispose();
 	}
 }
diff --git a/DisCatSharp.Lavalink/Entities/LavalinkEqualizerTypes.cs b/DisCatSharp.Lavalink/Entities/LavalinkEqualizerTypes.cs
index c06ba9c94..1d4af2375 100644
--- a/DisCatSharp.Lavalink/Entities/LavalinkEqualizerTypes.cs
+++ b/DisCatSharp.Lavalink/Entities/LavalinkEqualizerTypes.cs
@@ -1,84 +1,84 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Lavalink;
 
 /// <summary>
 /// Represents Lavalink equalizer band adjustment. This is used to alter the sound output by using Lavalink's equalizer.
 /// </summary>
-public struct LavalinkBandAdjustment
+public readonly struct LavalinkBandAdjustment
 {
 	/// <summary>
 	/// Gets the ID of the band to adjust.
 	/// </summary>
 	[JsonProperty("band")]
 	public int BandId { get; }
 
 	/// <summary>
 	/// Gets the gain of the specified band.
 	/// </summary>
 	[JsonProperty("gain")]
 	public float Gain { get; }
 
 	/// <summary>
 	/// Creates a new band adjustment with specified parameters.
 	/// </summary>
 	/// <param name="bandId">Which band to adjust. Must be in 0-14 range.</param>
 	/// <param name="gain">By how much to adjust the band. Must be greater than or equal to -0.25 (muted), and less than or equal to +1.0. +0.25 means the band is doubled.</param>
 	public LavalinkBandAdjustment(int bandId, float gain)
 	{
 		if (bandId < 0 || bandId > 14)
 			throw new ArgumentOutOfRangeException(nameof(bandId), "Band ID cannot be lower than 0 or greater than 14.");
 
 		if (gain < -0.25 || gain > 1.0)
 			throw new ArgumentOutOfRangeException(nameof(gain), "Gain cannot be lower than -0.25 or greater than 1.0.");
 
 		this.BandId = bandId;
 		this.Gain = gain;
 	}
 }
 
 /// <summary>
 /// The lavalink band adjustment comparer.
 /// </summary>
 internal class LavalinkBandAdjustmentComparer : IEqualityComparer<LavalinkBandAdjustment>
 {
 	/// <summary>
 	/// Whether two band adjustments are equal.
 	/// </summary>
 	/// <param name="x">The first band adjustments.</param>
 	/// <param name="y">The second band adjustments.</param>
 	public bool Equals(LavalinkBandAdjustment x, LavalinkBandAdjustment y)
 		=> x.BandId == y.BandId;
 
 	/// <summary>
 	/// Gets the hash code.
 	/// </summary>
 	/// <param name="obj">The band adjustments.</param>
 	public int GetHashCode(LavalinkBandAdjustment obj)
 		=> obj.BandId;
 }
diff --git a/DisCatSharp.Lavalink/LavalinkExtension.cs b/DisCatSharp.Lavalink/LavalinkExtension.cs
index 7f2159754..18d65f7ea 100644
--- a/DisCatSharp.Lavalink/LavalinkExtension.cs
+++ b/DisCatSharp.Lavalink/LavalinkExtension.cs
@@ -1,215 +1,215 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 
 namespace DisCatSharp.Lavalink;
 
 /// <summary>
 /// The lavalink extension.
 /// </summary>
 public sealed class LavalinkExtension : BaseExtension
 {
 	/// <summary>
 	/// Triggered whenever a node disconnects.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> NodeDisconnected
 	{
 		add => this._nodeDisconnected.Register(value);
 		remove => this._nodeDisconnected.Unregister(value);
 	}
 	private AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _nodeDisconnected;
 
 	/// <summary>
 	/// Gets a dictionary of connected Lavalink nodes for the extension.
 	/// </summary>
 	public IReadOnlyDictionary<ConnectionEndpoint, LavalinkNodeConnection> ConnectedNodes { get; }
 	private readonly ConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection> _connectedNodes = new();
 
 	/// <summary>
 	/// Creates a new instance of this Lavalink extension.
 	/// </summary>
 	internal LavalinkExtension()
 	{
 		this.ConnectedNodes = new ReadOnlyConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection>(this._connectedNodes);
 	}
 
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 	/// <exception cref="InvalidOperationException"/>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this._nodeDisconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Client.EventErrorHandler);
 	}
 
 	/// <summary>
 	/// Connect to a Lavalink node.
 	/// </summary>
 	/// <param name="config">Lavalink client configuration.</param>
 	/// <returns>The established Lavalink connection.</returns>
 	public async Task<LavalinkNodeConnection> ConnectAsync(LavalinkConfiguration config)
 	{
-		if (this._connectedNodes.ContainsKey(config.SocketEndpoint))
-			return this._connectedNodes[config.SocketEndpoint];
+		if (this._connectedNodes.TryGetValue(config.SocketEndpoint, out var endpoint))
+			return endpoint;
 
 		var con = new LavalinkNodeConnection(this.Client, this, config);
 		con.NodeDisconnected += this.Con_NodeDisconnected;
 		con.Disconnected += this.Con_Disconnected;
 		this._connectedNodes[con.NodeEndpoint] = con;
 		try
 		{
 			await con.StartAsync().ConfigureAwait(false);
 		}
 		catch
 		{
 			this.Con_NodeDisconnected(con);
 			throw;
 		}
 
 		return con;
 	}
 
 	/// <summary>
 	/// Gets the Lavalink node connection for the specified endpoint.
 	/// </summary>
 	/// <param name="endpoint">Endpoint at which the node resides.</param>
 	/// <returns>Lavalink node connection.</returns>
-	public LavalinkNodeConnection GetNodeConnection(ConnectionEndpoint endpoint)
-		=> this._connectedNodes.ContainsKey(endpoint) ? this._connectedNodes[endpoint] : null;
+	public LavalinkNodeConnection? GetNodeConnection(ConnectionEndpoint endpoint)
+		=> this._connectedNodes.TryGetValue(endpoint, out var value) ? value : null;
 
 	/// <summary>
 	/// Gets a Lavalink node connection based on load balancing and an optional voice region.
 	/// </summary>
 	/// <param name="region">The region to compare with the node's <see cref="LavalinkConfiguration.Region"/>, if any.</param>
 	/// <returns>The least load affected node connection, or null if no nodes are present.</returns>
-	public LavalinkNodeConnection GetIdealNodeConnection(DiscordVoiceRegion region = null)
+	public LavalinkNodeConnection? GetIdealNodeConnection(DiscordVoiceRegion? region = null)
 	{
 		if (this._connectedNodes.Count <= 1)
 			return this._connectedNodes.Values.FirstOrDefault();
 
 		var nodes = this._connectedNodes.Values.ToArray();
 
 		if (region != null)
 		{
 			var regionPredicate = new Func<LavalinkNodeConnection, bool>(x => x.Region == region);
 
 			if (nodes.Any(regionPredicate))
 				nodes = nodes.Where(regionPredicate).ToArray();
 
 			if (nodes.Length <= 1)
 				return nodes.FirstOrDefault();
 		}
 
 		return this.FilterByLoad(nodes);
 	}
 
 	/// <summary>
 	/// Gets a Lavalink guild connection from a <see cref="DisCatSharp.Entities.DiscordGuild"/>.
 	/// </summary>
 	/// <param name="guild">The guild the connection is on.</param>
 	/// <returns>The found guild connection, or null if one could not be found.</returns>
 	public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 	{
 		var nodes = this._connectedNodes.Values;
 		var node = nodes.FirstOrDefault(x => x.ConnectedGuildsInternal.ContainsKey(guild.Id));
 		return node?.GetGuildConnection(guild);
 	}
 
 	/// <summary>
 	/// Filters the by load.
 	/// </summary>
 	/// <param name="nodes">The nodes.</param>
 	private LavalinkNodeConnection FilterByLoad(LavalinkNodeConnection[] nodes)
 	{
 		Array.Sort(nodes, (a, b) =>
 		{
 			if (!a.Statistics.Updated || !b.Statistics.Updated)
 				return 0;
 
 			//https://github.com/FredBoat/Lavalink-Client/blob/48bc27784f57be5b95d2ff2eff6665451b9366f5/src/main/java/lavalink/client/io/LavalinkLoadBalancer.java#L122
 			//https://github.com/briantanner/eris-lavalink/blob/master/src/PlayerManager.js#L329
 
 			//player count
 			var aPenaltyCount = a.Statistics.ActivePlayers;
 			var bPenaltyCount = b.Statistics.ActivePlayers;
 
 			//cpu load
 			aPenaltyCount += (int)Math.Pow(1.05d, (100 * (a.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 			bPenaltyCount += (int)Math.Pow(1.05d, (100 * (b.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 
 			//frame load
 			if (a.Statistics.AverageDeficitFramesPerMinute > 0)
 			{
 				//deficit frame load
 				aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 				//null frame load
 				aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 			}
 
 			//frame load
 			if (b.Statistics.AverageDeficitFramesPerMinute > 0)
 			{
 				//deficit frame load
 				bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 				//null frame load
 				bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 			}
 
 			return aPenaltyCount - bPenaltyCount;
 		});
 
 		return nodes[0];
 	}
 
 	/// <summary>
 	/// Removes a node.
 	/// </summary>
 	/// <param name="node">The node to be removed.</param>
 	private void Con_NodeDisconnected(LavalinkNodeConnection node)
 		=> this._connectedNodes.TryRemove(node.NodeEndpoint, out _);
 
 	/// <summary>
 	/// Disconnects a node.
 	/// </summary>
 	/// <param name="node">The affected node.</param>
 	/// <param name="e">The node disconnected event args.</param>
 	private Task Con_Disconnected(LavalinkNodeConnection node, NodeDisconnectedEventArgs e)
 		=> this._nodeDisconnected.InvokeAsync(node, e);
 }
diff --git a/DisCatSharp.Lavalink/LavalinkNodeConnection.cs b/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
index ded9d142b..accda9dd1 100644
--- a/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
+++ b/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
@@ -1,626 +1,626 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Lavalink.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.Net.WebSocket;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Lavalink;
 
 internal delegate void NodeDisconnectedEventHandler(LavalinkNodeConnection node);
 
 /// <summary>
 /// Represents a connection to a Lavalink node.
 /// </summary>
 public sealed class LavalinkNodeConnection
 {
 	/// <summary>
 	/// Triggered whenever Lavalink WebSocket throws an exception.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, SocketErrorEventArgs> LavalinkSocketErrored
 	{
 		add => this._lavalinkSocketError.Register(value);
 		remove => this._lavalinkSocketError.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkNodeConnection, SocketErrorEventArgs> _lavalinkSocketError;
 
 	/// <summary>
 	/// Triggered when this node disconnects.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> Disconnected
 	{
 		add => this._disconnected.Register(value);
 		remove => this._disconnected.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _disconnected;
 
 	/// <summary>
 	/// Triggered when this node receives a statistics update.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, StatisticsReceivedEventArgs> StatisticsReceived
 	{
 		add => this._statsReceived.Register(value);
 		remove => this._statsReceived.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkNodeConnection, StatisticsReceivedEventArgs> _statsReceived;
 
 	/// <summary>
 	/// Triggered whenever any of the players on this node is updated.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, PlayerUpdateEventArgs> PlayerUpdated
 	{
 		add => this._playerUpdated.Register(value);
 		remove => this._playerUpdated.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs> _playerUpdated;
 
 	/// <summary>
 	/// Triggered whenever playback of a track starts.
 	/// <para>This is only available for version 3.3.1 and greater.</para>
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackStartEventArgs> PlaybackStarted
 	{
 		add => this._playbackStarted.Register(value);
 		remove => this._playbackStarted.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs> _playbackStarted;
 
 	/// <summary>
 	/// Triggered whenever playback of a track finishes.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackFinishEventArgs> PlaybackFinished
 	{
 		add => this._playbackFinished.Register(value);
 		remove => this._playbackFinished.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs> _playbackFinished;
 
 	/// <summary>
 	/// Triggered whenever playback of a track gets stuck.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackStuckEventArgs> TrackStuck
 	{
 		add => this._trackStuck.Register(value);
 		remove => this._trackStuck.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs> _trackStuck;
 
 	/// <summary>
 	/// Triggered whenever playback of a track encounters an error.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackExceptionEventArgs> TrackException
 	{
 		add => this._trackException.Register(value);
 		remove => this._trackException.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs> _trackException;
 
 	/// <summary>
 	/// Gets the remote endpoint of this Lavalink node connection.
 	/// </summary>
 	public ConnectionEndpoint NodeEndpoint => this.Configuration.SocketEndpoint;
 
 	/// <summary>
 	/// Gets whether the client is connected to Lavalink.
 	/// </summary>
 	public bool IsConnected => !Volatile.Read(ref this._isDisposed);
 	private bool _isDisposed;
 	private int _backoff;
 	/// <summary>
 	/// The minimum backoff.
 	/// </summary>
 	private const int MINIMUM_BACKOFF = 7500;
 	/// <summary>
 	/// The maximum backoff.
 	/// </summary>
 	private const int MAXIMUM_BACKOFF = 120000;
 
 	/// <summary>
 	/// Gets the current resource usage statistics.
 	/// </summary>
 	public LavalinkStatistics Statistics { get; }
 
 	/// <summary>
 	/// Gets a dictionary of Lavalink guild connections for this node.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, LavalinkGuildConnection> ConnectedGuilds { get; }
 	internal ConcurrentDictionary<ulong, LavalinkGuildConnection> ConnectedGuildsInternal = new();
 
 	/// <summary>
 	/// Gets the REST client for this Lavalink connection.
 	/// </summary>
 	public LavalinkRestClient Rest { get; }
 
 	/// <summary>
 	/// Gets the parent extension which this node connection belongs to.
 	/// </summary>
 	public LavalinkExtension Parent { get; }
 
 	/// <summary>
 	/// Gets the Discord client this node connection belongs to.
 	/// </summary>
 	public DiscordClient Discord { get; }
 
 	/// <summary>
 	/// Gets the configuration.
 	/// </summary>
 	internal LavalinkConfiguration Configuration { get; }
 	/// <summary>
 	/// Gets the region.
 	/// </summary>
 	internal DiscordVoiceRegion Region { get; }
 
 	/// <summary>
 	/// Gets or sets the web socket.
 	/// </summary>
 	private IWebSocketClient _webSocket;
 
 	/// <summary>
 	/// Gets the voice state updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> _voiceStateUpdates;
 
 	/// <summary>
 	/// Gets the voice server updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> _voiceServerUpdates;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="LavalinkNodeConnection"/> class.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="extension">the event.tension.</param>
 	/// <param name="config">The config.</param>
 	internal LavalinkNodeConnection(DiscordClient client, LavalinkExtension extension, LavalinkConfiguration config)
 	{
 		this.Discord = client;
 		this.Parent = extension;
 		this.Configuration = new LavalinkConfiguration(config);
 
 		if (config.Region != null && this.Discord.VoiceRegions.Values.Contains(config.Region))
 			this.Region = config.Region;
 
 		this.ConnectedGuilds = new ReadOnlyConcurrentDictionary<ulong, LavalinkGuildConnection>(this.ConnectedGuildsInternal);
 		this.Statistics = new LavalinkStatistics();
 
 		this._lavalinkSocketError = new AsyncEvent<LavalinkNodeConnection, SocketErrorEventArgs>("LAVALINK_SOCKET_ERROR", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._disconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._statsReceived = new AsyncEvent<LavalinkNodeConnection, StatisticsReceivedEventArgs>("LAVALINK_STATS_RECEIVED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._playerUpdated = new AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs>("LAVALINK_PLAYER_UPDATED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._playbackStarted = new AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs>("LAVALINK_PLAYBACK_STARTED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._playbackFinished = new AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs>("LAVALINK_PLAYBACK_FINISHED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._trackStuck = new AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs>("LAVALINK_TRACK_STUCK", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._trackException = new AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs>("LAVALINK_TRACK_EXCEPTION", TimeSpan.Zero, this.Discord.EventErrorHandler);
 
 		this._voiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
 		this._voiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
 		this.Discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated;
 		this.Discord.VoiceServerUpdated += this.Discord_VoiceServerUpdated;
 
 		this.Rest = new LavalinkRestClient(this.Configuration, this.Discord);
 
 		Volatile.Write(ref this._isDisposed, false);
 	}
 
 	/// <summary>
 	/// Establishes a connection to the Lavalink node.
 	/// </summary>
 	/// <returns></returns>
 	internal async Task StartAsync()
 	{
 		if (this.Discord?.CurrentUser?.Id == null || this.Discord?.ShardCount == null)
 			throw new InvalidOperationException("This operation requires the Discord client to be fully initialized.");
 
 		this._webSocket = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy, this.Discord.ServiceProvider);
 		this._webSocket.Connected += this.WebSocket_OnConnect;
 		this._webSocket.Disconnected += this.WebSocket_OnDisconnect;
 		this._webSocket.ExceptionThrown += this.WebSocket_OnException;
 		this._webSocket.MessageReceived += this.WebSocket_OnMessage;
 
 		this._webSocket.AddDefaultHeader("Authorization", this.Configuration.Password);
 		this._webSocket.AddDefaultHeader("Num-Shards", this.Discord.ShardCount.ToString(CultureInfo.InvariantCulture));
 		this._webSocket.AddDefaultHeader("User-Id", this.Discord.CurrentUser.Id.ToString(CultureInfo.InvariantCulture));
 		this._webSocket.AddDefaultHeader("Client-Name", $"DisCatSharp.Lavalink version {this.Discord.VersionString}");
 		if (this.Configuration.ResumeKey != null)
 			this._webSocket.AddDefaultHeader("Resume-Key", this.Configuration.ResumeKey);
 
 		do
 		{
 			try
 			{
 				if (this._backoff != 0)
 				{
 					await Task.Delay(this._backoff).ConfigureAwait(false);
 					this._backoff = Math.Min(this._backoff * 2, MAXIMUM_BACKOFF);
 				}
 				else
 				{
 					this._backoff = MINIMUM_BACKOFF;
 				}
 
 				await this._webSocket.ConnectAsync(new Uri(this.Configuration.SocketEndpoint.ToWebSocketString())).ConfigureAwait(false);
 				break;
 			}
 			catch (PlatformNotSupportedException)
 			{ throw; }
 			catch (NotImplementedException)
 			{ throw; }
 			catch (Exception ex)
 			{
 				if (!this.Configuration.SocketAutoReconnect || this._backoff == MAXIMUM_BACKOFF)
 				{
 					this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, ex, "Failed to connect to Lavalink.");
 					throw;
 				}
 				else
 				{
 					this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, ex, $"Failed to connect to Lavalink, retrying in {this._backoff} ms.");
 				}
 			}
 		}
 		while (this.Configuration.SocketAutoReconnect);
 
 		Volatile.Write(ref this._isDisposed, false);
 	}
 
 	/// <summary>
 	/// Stops this Lavalink node connection and frees resources.
 	/// </summary>
 	/// <returns></returns>
 	public async Task StopAsync()
 	{
 		foreach (var kvp in this.ConnectedGuildsInternal)
 			await kvp.Value.DisconnectAsync().ConfigureAwait(false);
 
 		this.NodeDisconnected?.Invoke(this);
 
 		Volatile.Write(ref this._isDisposed, true);
 		await this._webSocket.DisconnectAsync().ConfigureAwait(false);
 		// this should not be here, no?
 		//await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Connects this Lavalink node to specified Discord channel.
 	/// </summary>
 	/// <param name="channel">Voice channel to connect to.</param>
 	/// <returns>Channel connection, which allows for playback control.</returns>
 	public async Task<LavalinkGuildConnection> ConnectAsync(DiscordChannel channel)
 	{
-		if (this.ConnectedGuildsInternal.ContainsKey(channel.Guild.Id))
-			return this.ConnectedGuildsInternal[channel.Guild.Id];
+		if (this.ConnectedGuildsInternal.TryGetValue(channel.Guild.Id, out var connection))
+			return connection;
 
 		if (channel.Guild == null || (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage))
 			throw new ArgumentException("Invalid channel specified.", nameof(channel));
 
 		var vstut = new TaskCompletionSource<VoiceStateUpdateEventArgs>();
 		var vsrut = new TaskCompletionSource<VoiceServerUpdateEventArgs>();
 		this._voiceStateUpdates[channel.Guild.Id] = vstut;
 		this._voiceServerUpdates[channel.Guild.Id] = vsrut;
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = channel.Guild.Id,
 				ChannelId = channel.Id,
 				Deafened = false,
 				Muted = false
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (channel.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 		var vstu = await vstut.Task.ConfigureAwait(false);
 		var vsru = await vsrut.Task.ConfigureAwait(false);
 		await this.SendPayloadAsync(new LavalinkVoiceUpdate(vstu, vsru)).ConfigureAwait(false);
 
 		var con = new LavalinkGuildConnection(this, channel, vstu);
 		con.ChannelDisconnected += this.Con_ChannelDisconnected;
 		con.PlayerUpdated += (s, e) => this._playerUpdated.InvokeAsync(s, e);
 		con.PlaybackStarted += (s, e) => this._playbackStarted.InvokeAsync(s, e);
 		con.PlaybackFinished += (s, e) => this._playbackFinished.InvokeAsync(s, e);
 		con.TrackStuck += (s, e) => this._trackStuck.InvokeAsync(s, e);
 		con.TrackException += (s, e) => this._trackException.InvokeAsync(s, e);
 		this.ConnectedGuildsInternal[channel.Guild.Id] = con;
 
 		return con;
 	}
 
 	/// <summary>
 	/// Gets a Lavalink connection to specified Discord channel.
 	/// </summary>
 	/// <param name="guild">Guild to get connection for.</param>
 	/// <returns>Channel connection, which allows for playback control.</returns>
 	public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 		=> this.ConnectedGuildsInternal.TryGetValue(guild.Id, out var lgc) && lgc.IsConnected ? lgc : null;
 
 	/// <summary>
 	/// Sends the payload async.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 	internal async Task SendPayloadAsync(LavalinkPayload payload)
 		=> await this.WsSendAsync(JsonConvert.SerializeObject(payload, Formatting.None)).ConfigureAwait(false);
 
 	/// <summary>
 	/// Webs the socket_ on message.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.ent.</param>
 	private async Task WebSocket_OnMessage(IWebSocketClient client, SocketMessageEventArgs e)
 	{
 		if (e is not SocketTextMessageEventArgs et)
 		{
 			this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, "Lavalink sent binary data - unable to process");
 			return;
 		}
 
 		this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsRx, et.Message);
 
 		var json = et.Message;
 		var jsonData = JObject.Parse(json);
 		switch (jsonData["op"].ToString())
 		{
 			case "playerUpdate":
 				var gid = (ulong)jsonData["guildId"];
 				var state = jsonData["state"].ToObject<LavalinkState>();
 				if (this.ConnectedGuildsInternal.TryGetValue(gid, out var lvl))
 					await lvl.InternalUpdatePlayerStateAsync(state).ConfigureAwait(false);
 				break;
 
 			case "stats":
 				var statsRaw = jsonData.ToObject<LavalinkStats>();
 				this.Statistics.Update(statsRaw);
 				await this._statsReceived.InvokeAsync(this, new StatisticsReceivedEventArgs(this.Discord.ServiceProvider, this.Statistics)).ConfigureAwait(false);
 				break;
 
 			case "event":
 				var evtype = jsonData["type"].ToObject<EventType>();
 				var guildId = (ulong)jsonData["guildId"];
 				switch (evtype)
 				{
 					case EventType.TrackStartEvent:
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvtst))
 							await lvlEvtst.InternalPlaybackStartedAsync(jsonData["track"].ToString()).ConfigureAwait(false);
 						break;
 
 					case EventType.TrackEndEvent:
 						var reason = TrackEndReason.Cleanup;
 						switch (jsonData["reason"].ToString())
 						{
 							case "FINISHED":
 								reason = TrackEndReason.Finished;
 								break;
 							case "LOAD_FAILED":
 								reason = TrackEndReason.LoadFailed;
 								break;
 							case "STOPPED":
 								reason = TrackEndReason.Stopped;
 								break;
 							case "REPLACED":
 								reason = TrackEndReason.Replaced;
 								break;
 							case "CLEANUP":
 								reason = TrackEndReason.Cleanup;
 								break;
 						}
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvtf))
 							await lvlEvtf.InternalPlaybackFinishedAsync(new TrackFinishData { Track = jsonData["track"].ToString(), Reason = reason }).ConfigureAwait(false);
 						break;
 
 					case EventType.TrackStuckEvent:
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvts))
 							await lvlEvts.InternalTrackStuckAsync(new TrackStuckData { Track = jsonData["track"].ToString(), Threshold = (long)jsonData["thresholdMs"] }).ConfigureAwait(false);
 						break;
 
 					case EventType.TrackExceptionEvent:
 						var severity = LoadFailedSeverity.Common;
 
 						switch (jsonData["severity"].ToString())
 						{
 							case "COMMON":
 								severity = LoadFailedSeverity.Common;
 								break;
 
 							case "SUSPICIOUS":
 								severity = LoadFailedSeverity.Suspicious;
 								break;
 
 							case "FAULT":
 								severity = LoadFailedSeverity.Fault;
 								break;
 						}
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvte))
 							await lvlEvte.InternalTrackExceptionAsync(new LavalinkLoadFailedInfo { Message = jsonData["message"].ToString(), Severity = severity }, jsonData["track"].ToString()).ConfigureAwait(false);
 						break;
 
 					case EventType.WebSocketClosedEvent:
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEwsce))
 						{
 							lvlEwsce.VoiceWsDisconnectTcs.SetResult(true);
 							await lvlEwsce.InternalWebSocketClosedAsync(new WebSocketCloseEventArgs(jsonData["code"].ToObject<int>(), jsonData["reason"].ToString(), jsonData["byRemote"].ToObject<bool>(), this.Discord.ServiceProvider)).ConfigureAwait(false);
 						}
 						break;
 				}
 				break;
 		}
 	}
 
 	/// <summary>
 	/// Webs the socket_ on exception.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private Task WebSocket_OnException(IWebSocketClient client, SocketErrorEventArgs e)
 		=> this._lavalinkSocketError.InvokeAsync(this, new SocketErrorEventArgs(client.ServiceProvider) { Exception = e.Exception });
 
 	/// <summary>
 	/// Webs the socket_ on disconnect.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private async Task WebSocket_OnDisconnect(IWebSocketClient client, SocketCloseEventArgs e)
 	{
 		if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
 		{
 			this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Connection broken ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
 			await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
 
 			if (this.Configuration.SocketAutoReconnect)
 				await this.StartAsync().ConfigureAwait(false);
 		}
 		else if (e.CloseCode != 1001 && e.CloseCode != -1)
 		{
 			this.Discord.Logger.LogInformation(LavalinkEvents.LavalinkConnectionClosed, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 			this.NodeDisconnected?.Invoke(this);
 			await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, true)).ConfigureAwait(false);
 		}
 		else
 		{
 			Volatile.Write(ref this._isDisposed, true);
 			this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Lavalink died");
 			foreach (var kvp in this.ConnectedGuildsInternal)
 			{
 				await kvp.Value.SendVoiceUpdateAsync().ConfigureAwait(false);
 				_ = this.ConnectedGuildsInternal.TryRemove(kvp.Key, out _);
 			}
 			this.NodeDisconnected?.Invoke(this);
 			await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
 
 			if (this.Configuration.SocketAutoReconnect)
 				await this.StartAsync().ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Webs the socket_ on connect.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="ea">the event..</param>
 	private async Task WebSocket_OnConnect(IWebSocketClient client, SocketEventArgs ea)
 	{
 		this.Discord.Logger.LogDebug(LavalinkEvents.LavalinkConnected, "Connection to Lavalink node established");
 		this._backoff = 0;
 
 		if (this.Configuration.ResumeKey != null)
 			await this.SendPayloadAsync(new LavalinkConfigureResume(this.Configuration.ResumeKey, this.Configuration.ResumeTimeout)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Con_S the channel disconnected.
 	/// </summary>
 	/// <param name="con">The con.</param>
 	private void Con_ChannelDisconnected(LavalinkGuildConnection con)
 		=> this.ConnectedGuildsInternal.TryRemove(con.GuildId, out _);
 
 	/// <summary>
 	/// Discord voice state updated.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private Task Discord_VoiceStateUpdated(DiscordClient client, VoiceStateUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (e.User == null)
 			return Task.CompletedTask;
 
 		if (e.User.Id == this.Discord.CurrentUser.Id)
 		{
 			if (this.ConnectedGuildsInternal.TryGetValue(e.Guild.Id, out var lvlgc))
 				lvlgc.VoiceStateUpdate = e;
 
 			if (e.After.Channel == null && this.IsConnected && this.ConnectedGuildsInternal.ContainsKey(gld.Id))
 			{
 				_ = Task.Run(async () =>
 				{
 					var delayTask = Task.Delay(this.Configuration.WebSocketCloseTimeout);
 					var tcs = lvlgc.VoiceWsDisconnectTcs.Task;
 					_ = await Task.WhenAny(delayTask, tcs).ConfigureAwait(false);
 
 					await lvlgc.DisconnectInternalAsync(false, true).ConfigureAwait(false);
 					_ = this.ConnectedGuildsInternal.TryRemove(gld.Id, out _);
 				});
 			}
 
 			if (!string.IsNullOrWhiteSpace(e.SessionId) && e.Channel != null && this._voiceStateUpdates.TryRemove(gld.Id, out var xe))
 				xe.SetResult(e);
 		}
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Discord voice server updated.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private Task Discord_VoiceServerUpdated(DiscordClient client, VoiceServerUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (this.ConnectedGuildsInternal.TryGetValue(e.Guild.Id, out var lvlgc))
 		{
 			var lvlp = new LavalinkVoiceUpdate(lvlgc.VoiceStateUpdate, e);
 			_ = Task.Run(() => this.WsSendAsync(JsonConvert.SerializeObject(lvlp)));
 		}
 
 		if (this._voiceServerUpdates.TryRemove(gld.Id, out var xe))
 			xe.SetResult(e);
 
 		return Task.CompletedTask;
 	}
 	/// <summary>
 	/// Ws the send async.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 
 	private async Task WsSendAsync(string payload)
 	{
 		this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsTx, payload);
 		await this._webSocket.SendMessageAsync(payload).ConfigureAwait(false);
 	}
 
 	internal event NodeDisconnectedEventHandler NodeDisconnected;
 }
diff --git a/DisCatSharp.Tests/DisCatSharp.EventHandlers.Tests/GlobalSuppressions.cs b/DisCatSharp.Tests/DisCatSharp.EventHandlers.Tests/GlobalSuppressions.cs
new file mode 100644
index 000000000..affff1aa2
--- /dev/null
+++ b/DisCatSharp.Tests/DisCatSharp.EventHandlers.Tests/GlobalSuppressions.cs
@@ -0,0 +1,20 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.HandlerB.MessageCreated(DisCatSharp.DiscordClient,DisCatSharp.EventArgs.MessageCreateEventArgs)~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.BadHandlerA.MessageCreated(System.Object,System.Object)~System.Int32")]
+[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.BadHandlerB.ThisEventDoesNotExist~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.HandlerB.MessageCreated(DisCatSharp.DiscordClient,DisCatSharp.EventArgs.MessageCreateEventArgs)~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.HandlerB.SomeEvent(DisCatSharp.DiscordClient,DisCatSharp.EventArgs.MessageDeleteEventArgs)~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.HandlerB.SomeEvent(DisCatSharp.DiscordClient,DisCatSharp.EventArgs.MessageDeleteEventArgs)~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.HandlerC.MessageCreated(DisCatSharp.DiscordClient,DisCatSharp.EventArgs.MessageCreateEventArgs)~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Style", "IDE0057:Use range operator", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.IsEventRegistered(System.String)~System.Boolean")]
+[assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.BadHandlerA.MessageCreated(System.Object,System.Object)~System.Int32")]
+[assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.BasicEventHandlerTests.HandlerD.ChannelCreated(DisCatSharp.DiscordClient,DisCatSharp.EventArgs.ChannelCreateEventArgs)~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.EventsEnumIntegrityTests.TestEnumToEvent")]
+[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.EventsEnumIntegrityTests.TestEventToEnum")]
+[assembly: SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.EventHandlers.Tests.ServiceProviderTests.Handler.#ctor(DisCatSharp.EventHandlers.Tests.ServiceProviderTests.Resource)")]
diff --git a/DisCatSharp.VoiceNext/AudioFormat.cs b/DisCatSharp.VoiceNext/AudioFormat.cs
index a2405bc26..2b037f789 100644
--- a/DisCatSharp.VoiceNext/AudioFormat.cs
+++ b/DisCatSharp.VoiceNext/AudioFormat.cs
@@ -1,163 +1,163 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Runtime.CompilerServices;
 
 namespace DisCatSharp.VoiceNext;
 
 /// <summary>
 /// Defines the format of PCM data consumed or produced by Opus.
 /// </summary>
-public struct AudioFormat
+public readonly struct AudioFormat
 {
 	/// <summary>
 	/// Gets the collection of sampling rates (in Hz) the Opus encoder can use.
 	/// </summary>
 	public static IReadOnlyCollection<int> AllowedSampleRates { get; } = new ReadOnlyCollection<int>(new[] { 8000, 12000, 16000, 24000, 48000 });
 
 	/// <summary>
 	/// Gets the collection of channel counts the Opus encoder can use.
 	/// </summary>
 	public static IReadOnlyCollection<int> AllowedChannelCounts { get; } = new ReadOnlyCollection<int>(new[] { 1, 2 });
 
 	/// <summary>
 	/// Gets the collection of sample durations (in ms) the Opus encoder can use.
 	/// </summary>
 	public static IReadOnlyCollection<int> AllowedSampleDurations { get; } = new ReadOnlyCollection<int>(new[] { 5, 10, 20, 40, 60 });
 
 	/// <summary>
 	/// Gets the default audio format. This is a format configured for 48kHz sampling rate, 2 channels, with music quality preset.
 	/// </summary>
 	public static AudioFormat Default { get; } = new(48000, 2, VoiceApplication.Music);
 
 	/// <summary>
 	/// Gets the audio sampling rate in Hz.
 	/// </summary>
 	public int SampleRate { get; }
 
 	/// <summary>
 	/// Gets the audio channel count.
 	/// </summary>
 	public int ChannelCount { get; }
 
 	/// <summary>
 	/// Gets the voice application, which dictates the quality preset.
 	/// </summary>
 	public VoiceApplication VoiceApplication { get; }
 
 	/// <summary>
 	/// Creates a new audio format for use with Opus encoder.
 	/// </summary>
 	/// <param name="sampleRate">Audio sampling rate in Hz.</param>
 	/// <param name="channelCount">Number of audio channels in the data.</param>
 	/// <param name="voiceApplication">Encoder preset to use.</param>
 	public AudioFormat(int sampleRate = 48000, int channelCount = 2, VoiceApplication voiceApplication = VoiceApplication.Music)
 	{
 		if (!AllowedSampleRates.Contains(sampleRate))
 			throw new ArgumentOutOfRangeException(nameof(sampleRate), "Invalid sample rate specified.");
 
 		if (!AllowedChannelCounts.Contains(channelCount))
 			throw new ArgumentOutOfRangeException(nameof(channelCount), "Invalid channel count specified.");
 
 		if (voiceApplication != VoiceApplication.Music && voiceApplication != VoiceApplication.Voice && voiceApplication != VoiceApplication.LowLatency)
 			throw new ArgumentOutOfRangeException(nameof(voiceApplication), "Invalid voice application specified.");
 
 		this.SampleRate = sampleRate;
 		this.ChannelCount = channelCount;
 		this.VoiceApplication = voiceApplication;
 	}
 
 	/// <summary>
 	/// Calculates a sample size in bytes.
 	/// </summary>
 	/// <param name="sampleDuration">Millisecond duration of a sample.</param>
 	/// <returns>Calculated sample size in bytes.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public int CalculateSampleSize(int sampleDuration)
 	{
 		if (!AllowedSampleDurations.Contains(sampleDuration))
 			throw new ArgumentOutOfRangeException(nameof(sampleDuration), "Invalid sample duration specified.");
 
 		// Sample size in bytes is a product of the following:
 		// - duration in milliseconds
 		// - number of channels
 		// - sample rate in kHz
 		// - size of data (in this case, sizeof(int16_t))
 		// which comes down to below:
 		return sampleDuration * this.ChannelCount * (this.SampleRate / 1000) * 2;
 	}
 
 	/// <summary>
 	/// Gets the maximum buffer size for decoding. This method should be called when decoding Opus data to PCM, to ensure sufficient buffer size.
 	/// </summary>
 	/// <returns>Buffer size required to decode data.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public int GetMaximumBufferSize()
 		=> this.CalculateMaximumFrameSize();
 
 	/// <summary>
 	/// Calculates the sample duration.
 	/// </summary>
 	/// <param name="sampleSize">The sample size.</param>
 	/// <returns>An int.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	internal int CalculateSampleDuration(int sampleSize)
 		=> sampleSize / (this.SampleRate / 1000) / this.ChannelCount / 2 /* sizeof(int16_t) */;
 
 	/// <summary>
 	/// Calculates the frame size.
 	/// </summary>
 	/// <param name="sampleDuration">The sample duration.</param>
 	/// <returns>An int.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	internal int CalculateFrameSize(int sampleDuration)
 		=> sampleDuration * (this.SampleRate / 1000);
 
 	/// <summary>
 	/// Calculates the maximum frame size.
 	/// </summary>
 	/// <returns>An int.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	internal int CalculateMaximumFrameSize()
 		=> 120 * (this.SampleRate / 1000);
 
 	/// <summary>
 	/// Samples the count to sample size.
 	/// </summary>
 	/// <param name="sampleCount">The sample count.</param>
 	/// <returns>An int.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	internal int SampleCountToSampleSize(int sampleCount)
 		=> sampleCount * this.ChannelCount * 2 /* sizeof(int16_t) */;
 
 	/// <summary>
 	/// Are the valid.
 	/// </summary>
 	/// <returns>A bool.</returns>
 	internal bool IsValid()
 		=> AllowedSampleRates.Contains(this.SampleRate) && AllowedChannelCounts.Contains(this.ChannelCount) &&
 			(this.VoiceApplication == VoiceApplication.Music || this.VoiceApplication == VoiceApplication.Voice || this.VoiceApplication == VoiceApplication.LowLatency);
 }
diff --git a/DisCatSharp.VoiceNext/Codec/Interop.cs b/DisCatSharp.VoiceNext/Codec/Interop.cs
index 9d9a732e3..dcd8e6736 100644
--- a/DisCatSharp.VoiceNext/Codec/Interop.cs
+++ b/DisCatSharp.VoiceNext/Codec/Interop.cs
@@ -1,392 +1,408 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Runtime.InteropServices;
 
 namespace DisCatSharp.VoiceNext.Codec;
 
 /// <summary>
 /// This is an interop class. It contains wrapper methods for Opus and Sodium.
 /// </summary>
-internal static class Interop
+internal static partial class Interop
 {
 	#region Sodium wrapper
 	/// <summary>
 	/// The sodium library name.
 	/// </summary>
 	private const string SODIUM_LIBRARY_NAME = "libsodium";
 
 	/// <summary>
 	/// Gets the Sodium key size for xsalsa20_poly1305 algorithm.
 	/// </summary>
 	public static int SodiumKeySize { get; } = (int)_SodiumSecretBoxKeySize();
 
 	/// <summary>
 	/// Gets the Sodium nonce size for xsalsa20_poly1305 algorithm.
 	/// </summary>
 	public static int SodiumNonceSize { get; } = (int)_SodiumSecretBoxNonceSize();
 
 	/// <summary>
 	/// Gets the Sodium MAC size for xsalsa20_poly1305 algorithm.
 	/// </summary>
 	public static int SodiumMacSize { get; } = (int)_SodiumSecretBoxMacSize();
 
 	/// <summary>
 	/// _S the sodium secret box key size.
 	/// </summary>
 	/// <returns>An UIntPtr.</returns>
-	[DllImport(SODIUM_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "crypto_secretbox_xsalsa20poly1305_keybytes")]
+	[LibraryImport(SODIUM_LIBRARY_NAME, EntryPoint = "crypto_secretbox_xsalsa20poly1305_keybytes")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
 	[return: MarshalAs(UnmanagedType.SysUInt)]
-	private static extern UIntPtr _SodiumSecretBoxKeySize();
+	private static partial UIntPtr _SodiumSecretBoxKeySize();
 
 	/// <summary>
 	/// _S the sodium secret box nonce size.
 	/// </summary>
 	/// <returns>An UIntPtr.</returns>
-	[DllImport(SODIUM_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "crypto_secretbox_xsalsa20poly1305_noncebytes")]
+	[LibraryImport(SODIUM_LIBRARY_NAME, EntryPoint = "crypto_secretbox_xsalsa20poly1305_noncebytes")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
 	[return: MarshalAs(UnmanagedType.SysUInt)]
-	private static extern UIntPtr _SodiumSecretBoxNonceSize();
+	private static partial UIntPtr _SodiumSecretBoxNonceSize();
 
 	/// <summary>
 	/// _S the sodium secret box mac size.
 	/// </summary>
 	/// <returns>An UIntPtr.</returns>
-	[DllImport(SODIUM_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "crypto_secretbox_xsalsa20poly1305_macbytes")]
+	[LibraryImport(SODIUM_LIBRARY_NAME, EntryPoint = "crypto_secretbox_xsalsa20poly1305_macbytes")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
 	[return: MarshalAs(UnmanagedType.SysUInt)]
-	private static extern UIntPtr _SodiumSecretBoxMacSize();
+	private static partial UIntPtr _SodiumSecretBoxMacSize();
 
 	/// <summary>
 	/// _S the sodium secret box create.
 	/// </summary>
 	/// <param name="buffer">The buffer.</param>
 	/// <param name="message">The message.</param>
 	/// <param name="messageLength">The message length.</param>
 	/// <param name="nonce">The nonce.</param>
 	/// <param name="key">The key.</param>
 	/// <returns>An int.</returns>
-	[DllImport(SODIUM_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "crypto_secretbox_easy")]
-	private static unsafe extern int _SodiumSecretBoxCreate(byte* buffer, byte* message, ulong messageLength, byte* nonce, byte* key);
+	[LibraryImport(SODIUM_LIBRARY_NAME, EntryPoint = "crypto_secretbox_easy")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _SodiumSecretBoxCreate(byte* buffer, byte* message, ulong messageLength, byte* nonce, byte* key);
 
 	/// <summary>
 	/// _S the sodium secret box open.
 	/// </summary>
 	/// <param name="buffer">The buffer.</param>
 	/// <param name="encryptedMessage">The encrypted message.</param>
 	/// <param name="encryptedLength">The encrypted length.</param>
 	/// <param name="nonce">The nonce.</param>
 	/// <param name="key">The key.</param>
 	/// <returns>An int.</returns>
-	[DllImport(SODIUM_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "crypto_secretbox_open_easy")]
-	private static unsafe extern int _SodiumSecretBoxOpen(byte* buffer, byte* encryptedMessage, ulong encryptedLength, byte* nonce, byte* key);
+	[LibraryImport(SODIUM_LIBRARY_NAME, EntryPoint = "crypto_secretbox_open_easy")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _SodiumSecretBoxOpen(byte* buffer, byte* encryptedMessage, ulong encryptedLength, byte* nonce, byte* key);
 
 	/// <summary>
 	/// Encrypts supplied buffer using xsalsa20_poly1305 algorithm, using supplied key and nonce to perform encryption.
 	/// </summary>
 	/// <param name="source">Contents to encrypt.</param>
 	/// <param name="target">Buffer to encrypt to.</param>
 	/// <param name="key">Key to use for encryption.</param>
 	/// <param name="nonce">Nonce to use for encryption.</param>
 	/// <returns>Encryption status.</returns>
 	public static unsafe int Encrypt(ReadOnlySpan<byte> source, Span<byte> target, ReadOnlySpan<byte> key, ReadOnlySpan<byte> nonce)
 	{
 		var status = 0;
 		fixed (byte* sourcePtr = &source.GetPinnableReference())
 		fixed (byte* targetPtr = &target.GetPinnableReference())
 		fixed (byte* keyPtr = &key.GetPinnableReference())
 		fixed (byte* noncePtr = &nonce.GetPinnableReference())
 			status = _SodiumSecretBoxCreate(targetPtr, sourcePtr, (ulong)source.Length, noncePtr, keyPtr);
 
 		return status;
 	}
 
 	/// <summary>
 	/// Decrypts supplied buffer using xsalsa20_poly1305 algorithm, using supplied key and nonce to perform decryption.
 	/// </summary>
 	/// <param name="source">Buffer to decrypt from.</param>
 	/// <param name="target">Decrypted message buffer.</param>
 	/// <param name="key">Key to use for decryption.</param>
 	/// <param name="nonce">Nonce to use for decryption.</param>
 	/// <returns>Decryption status.</returns>
 	public static unsafe int Decrypt(ReadOnlySpan<byte> source, Span<byte> target, ReadOnlySpan<byte> key, ReadOnlySpan<byte> nonce)
 	{
 		var status = 0;
 		fixed (byte* sourcePtr = &source.GetPinnableReference())
 		fixed (byte* targetPtr = &target.GetPinnableReference())
 		fixed (byte* keyPtr = &key.GetPinnableReference())
 		fixed (byte* noncePtr = &nonce.GetPinnableReference())
 			status = _SodiumSecretBoxOpen(targetPtr, sourcePtr, (ulong)source.Length, noncePtr, keyPtr);
 
 		return status;
 	}
 	#endregion
 
 	#region Opus wrapper
 	/// <summary>
 	/// The opus library name.
 	/// </summary>
 	private const string OPUS_LIBRARY_NAME = "libopus";
 
 	/// <summary>
 	/// _S the opus create encoder.
 	/// </summary>
 	/// <param name="sampleRate">The sample rate.</param>
 	/// <param name="channels">The channels.</param>
 	/// <param name="application">The application.</param>
 	/// <param name="error">The error.</param>
 	/// <returns>An IntPtr.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_encoder_create")]
-	private static extern IntPtr _OpusCreateEncoder(int sampleRate, int channels, int application, out OpusError error);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_encoder_create")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static partial IntPtr _OpusCreateEncoder(int sampleRate, int channels, int application, out OpusError error);
 
 	/// <summary>
 	/// Opuses the destroy encoder.
 	/// </summary>
 	/// <param name="encoder">The encoder.</param>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_encoder_destroy")]
-	public static extern void OpusDestroyEncoder(IntPtr encoder);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_encoder_destroy")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	public static partial void OpusDestroyEncoder(IntPtr encoder);
 
 	/// <summary>
 	/// _S the opus encode.
 	/// </summary>
 	/// <param name="encoder">The encoder.</param>
 	/// <param name="pcmData">The pcm data.</param>
 	/// <param name="frameSize">The frame size.</param>
 	/// <param name="data">The data.</param>
 	/// <param name="maxDataBytes">The max data bytes.</param>
 	/// <returns>An int.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_encode")]
-	private static unsafe extern int _OpusEncode(IntPtr encoder, byte* pcmData, int frameSize, byte* data, int maxDataBytes);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_encode")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _OpusEncode(IntPtr encoder, byte* pcmData, int frameSize, byte* data, int maxDataBytes);
 
 	/// <summary>
 	/// _S the opus encoder control.
 	/// </summary>
 	/// <param name="encoder">The encoder.</param>
 	/// <param name="request">The request.</param>
 	/// <param name="value">The value.</param>
 	/// <returns>An OpusError.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_encoder_ctl")]
-	private static extern OpusError _OpusEncoderControl(IntPtr encoder, OpusControl request, int value);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_encoder_ctl")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static partial OpusError _OpusEncoderControl(IntPtr encoder, OpusControl request, int value);
 
 	/// <summary>
 	/// _S the opus create decoder.
 	/// </summary>
 	/// <param name="sampleRate">The sample rate.</param>
 	/// <param name="channels">The channels.</param>
 	/// <param name="error">The error.</param>
 	/// <returns>An IntPtr.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_decoder_create")]
-	private static extern IntPtr _OpusCreateDecoder(int sampleRate, int channels, out OpusError error);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_decoder_create")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static partial IntPtr _OpusCreateDecoder(int sampleRate, int channels, out OpusError error);
 
 	/// <summary>
 	/// Opuses the destroy decoder.
 	/// </summary>
 	/// <param name="decoder">The decoder.</param>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_decoder_destroy")]
-	public static extern void OpusDestroyDecoder(IntPtr decoder);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_decoder_destroy")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	public static partial void OpusDestroyDecoder(IntPtr decoder);
 
 	/// <summary>
 	/// _S the opus decode.
 	/// </summary>
 	/// <param name="decoder">The decoder.</param>
 	/// <param name="opusData">The opus data.</param>
 	/// <param name="opusDataLength">The opus data length.</param>
 	/// <param name="data">The data.</param>
 	/// <param name="frameSize">The frame size.</param>
 	/// <param name="decodeFec">The decode fec.</param>
 	/// <returns>An int.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_decode")]
-	private static unsafe extern int _OpusDecode(IntPtr decoder, byte* opusData, int opusDataLength, byte* data, int frameSize, int decodeFec);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_decode")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _OpusDecode(IntPtr decoder, byte* opusData, int opusDataLength, byte* data, int frameSize, int decodeFec);
 
 	/// <summary>
 	/// _S the opus get packet channel count.
 	/// </summary>
 	/// <param name="opusData">The opus data.</param>
 	/// <returns>An int.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_packet_get_nb_channels")]
-	private static unsafe extern int _OpusGetPacketChannelCount(byte* opusData);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_packet_get_nb_channels")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _OpusGetPacketChannelCount(byte* opusData);
 
 	/// <summary>
 	/// _S the opus get packet frame count.
 	/// </summary>
 	/// <param name="opusData">The opus data.</param>
 	/// <param name="length">The length.</param>
 	/// <returns>An int.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_packet_get_nb_frames")]
-	private static unsafe extern int _OpusGetPacketFrameCount(byte* opusData, int length);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_packet_get_nb_frames")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _OpusGetPacketFrameCount(byte* opusData, int length);
 
 	/// <summary>
 	/// _S the opus get packet sample per frame count.
 	/// </summary>
 	/// <param name="opusData">The opus data.</param>
 	/// <param name="samplingRate">The sampling rate.</param>
 	/// <returns>An int.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_packet_get_samples_per_frame")]
-	private static unsafe extern int _OpusGetPacketSamplePerFrameCount(byte* opusData, int samplingRate);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_packet_get_samples_per_frame")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static unsafe partial int _OpusGetPacketSamplePerFrameCount(byte* opusData, int samplingRate);
 
 	/// <summary>
 	/// _S the opus decoder control.
 	/// </summary>
 	/// <param name="decoder">The decoder.</param>
 	/// <param name="request">The request.</param>
 	/// <param name="value">The value.</param>
 	/// <returns>An int.</returns>
-	[DllImport(OPUS_LIBRARY_NAME, CallingConvention = CallingConvention.Cdecl, EntryPoint = "opus_decoder_ctl")]
-	private static extern int _OpusDecoderControl(IntPtr decoder, OpusControl request, out int value);
+	[LibraryImport(OPUS_LIBRARY_NAME, EntryPoint = "opus_decoder_ctl")]
+	[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+	private static partial int _OpusDecoderControl(IntPtr decoder, OpusControl request, out int value);
 
 	/// <summary>
 	/// Opuses the create encoder.
 	/// </summary>
 	/// <param name="audioFormat">The audio format.</param>
 	/// <returns>An IntPtr.</returns>
 	public static IntPtr OpusCreateEncoder(AudioFormat audioFormat)
 	{
 		var encoder = _OpusCreateEncoder(audioFormat.SampleRate, audioFormat.ChannelCount, (int)audioFormat.VoiceApplication, out var error);
 		return error != OpusError.Ok ? throw new Exception($"Could not instantiate Opus encoder: {error} ({(int)error}).") : encoder;
 	}
 
 	/// <summary>
 	/// Opuses the set encoder option.
 	/// </summary>
 	/// <param name="encoder">The encoder.</param>
 	/// <param name="option">The option.</param>
 	/// <param name="value">The value.</param>
 	public static void OpusSetEncoderOption(IntPtr encoder, OpusControl option, int value)
 	{
 		var error = OpusError.Ok;
 		if ((error = _OpusEncoderControl(encoder, option, value)) != OpusError.Ok)
 			throw new Exception($"Could not set Opus encoder option: {error} ({(int)error}).");
 	}
 
 	/// <summary>
 	/// Opuses the encode.
 	/// </summary>
 	/// <param name="encoder">The encoder.</param>
 	/// <param name="pcm">The pcm.</param>
 	/// <param name="frameSize">The frame size.</param>
 	/// <param name="opus">The opus.</param>
 	public static unsafe void OpusEncode(IntPtr encoder, ReadOnlySpan<byte> pcm, int frameSize, ref Span<byte> opus)
 	{
 		var len = 0;
 
 		fixed (byte* pcmPtr = &pcm.GetPinnableReference())
 		fixed (byte* opusPtr = &opus.GetPinnableReference())
 			len = _OpusEncode(encoder, pcmPtr, frameSize, opusPtr, opus.Length);
 
 		if (len < 0)
 		{
 			var error = (OpusError)len;
 			throw new Exception($"Could not encode PCM data to Opus: {error} ({(int)error}).");
 		}
 
 		opus = opus[..len];
 	}
 
 	/// <summary>
 	/// Opuses the create decoder.
 	/// </summary>
 	/// <param name="audioFormat">The audio format.</param>
 	/// <returns>An IntPtr.</returns>
 	public static IntPtr OpusCreateDecoder(AudioFormat audioFormat)
 	{
 		var decoder = _OpusCreateDecoder(audioFormat.SampleRate, audioFormat.ChannelCount, out var error);
 		return error != OpusError.Ok ? throw new Exception($"Could not instantiate Opus decoder: {error} ({(int)error}).") : decoder;
 	}
 
 	/// <summary>
 	/// Opuses the decode.
 	/// </summary>
 	/// <param name="decoder">The decoder.</param>
 	/// <param name="opus">The opus.</param>
 	/// <param name="frameSize">The frame size.</param>
 	/// <param name="pcm">The pcm.</param>
 	/// <param name="useFec">If true, use fec.</param>
 	/// <returns>An int.</returns>
 	public static unsafe int OpusDecode(IntPtr decoder, ReadOnlySpan<byte> opus, int frameSize, Span<byte> pcm, bool useFec)
 	{
 		var len = 0;
 
 		fixed (byte* opusPtr = &opus.GetPinnableReference())
 		fixed (byte* pcmPtr = &pcm.GetPinnableReference())
 			len = _OpusDecode(decoder, opusPtr, opus.Length, pcmPtr, frameSize, useFec ? 1 : 0);
 
 		if (len < 0)
 		{
 			var error = (OpusError)len;
 			throw new Exception($"Could not decode PCM data from Opus: {error} ({(int)error}).");
 		}
 
 		return len;
 	}
 
 	/// <summary>
 	/// Opuses the decode.
 	/// </summary>
 	/// <param name="decoder">The decoder.</param>
 	/// <param name="frameSize">The frame size.</param>
 	/// <param name="pcm">The pcm.</param>
 	/// <returns>An int.</returns>
 	public static unsafe int OpusDecode(IntPtr decoder, int frameSize, Span<byte> pcm)
 	{
 		var len = 0;
 
 		fixed (byte* pcmPtr = &pcm.GetPinnableReference())
 			len = _OpusDecode(decoder, null, 0, pcmPtr, frameSize, 1);
 
 		if (len < 0)
 		{
 			var error = (OpusError)len;
 			throw new Exception($"Could not decode PCM data from Opus: {error} ({(int)error}).");
 		}
 
 		return len;
 	}
 
 	/// <summary>
 	/// Opuses the get packet metrics.
 	/// </summary>
 	/// <param name="opus">The opus.</param>
 	/// <param name="samplingRate">The sampling rate.</param>
 	/// <param name="channels">The channels.</param>
 	/// <param name="frames">The frames.</param>
 	/// <param name="samplesPerFrame">The samples per frame.</param>
 	/// <param name="frameSize">The frame size.</param>
 	public static unsafe void OpusGetPacketMetrics(ReadOnlySpan<byte> opus, int samplingRate, out int channels, out int frames, out int samplesPerFrame, out int frameSize)
 	{
 		fixed (byte* opusPtr = &opus.GetPinnableReference())
 		{
 			frames = _OpusGetPacketFrameCount(opusPtr, opus.Length);
 			samplesPerFrame = _OpusGetPacketSamplePerFrameCount(opusPtr, samplingRate);
 			channels = _OpusGetPacketChannelCount(opusPtr);
 		}
 
 		frameSize = frames * samplesPerFrame;
 	}
 
 	/// <summary>
 	/// Opuses the get last packet duration.
 	/// </summary>
 	/// <param name="decoder">The decoder.</param>
 	/// <param name="sampleCount">The sample count.</param>
 	public static void OpusGetLastPacketDuration(IntPtr decoder, out int sampleCount)
 		=> _OpusDecoderControl(decoder, OpusControl.GetLastPacketDuration, out sampleCount);
 	#endregion
 }
diff --git a/DisCatSharp.VoiceNext/Interop/Bindings.cs b/DisCatSharp.VoiceNext/Interop/Bindings.cs
index 3698be98f..06fdd2dca 100644
--- a/DisCatSharp.VoiceNext/Interop/Bindings.cs
+++ b/DisCatSharp.VoiceNext/Interop/Bindings.cs
@@ -1,155 +1,166 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Runtime.InteropServices;
 
 namespace DisCatSharp.VoiceNext.Interop
 {
-	internal static unsafe class Bindings
+	internal static unsafe partial class Bindings
 	{
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern IntPtr opus_encoder_create(int samplingRate, int channels, int application, out OpusError error);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial IntPtr opus_encoder_create(int samplingRate, int channels, int application, out OpusError error);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern void opus_encoder_destroy(IntPtr encoder);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial void opus_encoder_destroy(IntPtr encoder);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern int opus_encode(IntPtr encoder, byte* pcm, int frameSize, byte* data, int maxDataBytes);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial int opus_encode(IntPtr encoder, byte* pcm, int frameSize, byte* data, int maxDataBytes);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern OpusError opus_encoder_ctl(IntPtr encoder, OpusControl ctl, int value);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial OpusError opus_encoder_ctl(IntPtr encoder, OpusControl ctl, int value);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern IntPtr opus_decoder_create(int sampleRate, int channels, out OpusError error);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial IntPtr opus_decoder_create(int sampleRate, int channels, out OpusError error);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern void opus_decoder_destroy(IntPtr decoder);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial void opus_decoder_destroy(IntPtr decoder);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern int opus_decode(IntPtr decoder, byte* opusData, int opusDataLength, byte* data, int frameSize, int decodeFec);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial int opus_decode(IntPtr decoder, byte* opusData, int opusDataLength, byte* data, int frameSize, int decodeFec);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern int opus_packet_get_nb_channels(byte* data);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial int opus_packet_get_nb_channels(byte* data);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern int opus_packet_get_nb_frames(byte* data, int length);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial int opus_packet_get_nb_frames(byte* data, int length);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern int opus_packet_get_samples_per_frame(byte* data, int samplingRate);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial int opus_packet_get_samples_per_frame(byte* data, int samplingRate);
 
-		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
-		private static extern int opus_decoder_ctl(IntPtr decoder, OpusControl ctl, out int value);
+		[LibraryImport("libopus")]
+		[UnmanagedCallConv(CallConvs = new Type[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
+		private static partial int opus_decoder_ctl(IntPtr decoder, OpusControl ctl, out int value);
 
 		public static IntPtr CreateEncoder(int sampleRate, int channelCount, int application)
 		{
 			var encoder = opus_encoder_create(sampleRate, channelCount, application, out var error);
 			return error == OpusError.Ok ? encoder : throw new Exception($"Failed to instantiate Opus encoder: {error} ({(int)error})");
 		}
 
 		public static void SetEncoderOption(IntPtr encoder, OpusControl option, int value)
 		{
 			var error = OpusError.Ok;
 			if ((error = opus_encoder_ctl(encoder, option, value)) != OpusError.Ok)
 				throw new Exception($"Failed to set Opus encoder option: ${error} ({(int)error})");
 		}
 
 		public static void Encode(IntPtr encoder, ReadOnlySpan<byte> pcm, int frameSize, ref Span<byte> data)
 		{
 			var length = 0;
 
 			fixed (byte* pcmPointer = pcm)
 			fixed (byte* dataPointer = data)
 				length = opus_encode(encoder, pcmPointer, frameSize, dataPointer, data.Length);
 
 			if (length < 0)
 			{
 				var error = (OpusError)length;
 				throw new Exception($"Failed to encode PCM data: {error} ({length})");
 			}
 
 			data = data[..length];
 		}
 
 		public static IntPtr CreateDecoder(int sampleRate, int channelCount)
 		{
 			var decoder = opus_decoder_create(sampleRate, channelCount, out var error);
 			return error == OpusError.Ok ? decoder : throw new Exception($"Failed to instantiate Opus decoder: {error} ({(int)error})");
 		}
 
 		public static int Decode(IntPtr decoder, ReadOnlySpan<byte> data, int frameSize, Span<byte> pcm, bool useFec)
 		{
 			var length = 0;
 
 			fixed (byte* dataPointer = data)
 			fixed (byte* pcmPointer = pcm)
 				length = opus_decode(decoder, dataPointer, data.Length, pcmPointer, frameSize, useFec ? 1 : 0);
 
 			if (length < 0)
 			{
 				var error = (OpusError)length;
 				throw new Exception($"Failed to decode PCM data: {error} ({length})");
 			}
 
 			return length;
 		}
 
 		public static int Decode(IntPtr decoder, int frameSize, Span<byte> pcm)
 		{
 			var length = 0;
 
 			fixed (byte* pcmPointer = pcm)
 				length = opus_decode(decoder, null, 0, pcmPointer, frameSize, 1);
 
 			if (length < 0)
 			{
 				var error = (OpusError)length;
 				throw new Exception($"Failed to decode PCM data: {error} ({length})");
 			}
 
 			return length;
 		}
 
 		public static OpusPacketMetrics GetPacketMetrics(ReadOnlySpan<byte> data, int samplingRate)
 		{
 			int channels, frames, samplesPerFrame;
 
 			fixed (byte* dataPointer = data)
 			{
 				frames = opus_packet_get_nb_frames(dataPointer, data.Length);
 				samplesPerFrame = opus_packet_get_samples_per_frame(dataPointer, samplingRate);
 				channels = opus_packet_get_nb_channels(dataPointer);
 			}
 
 			return new()
 			{
 				ChannelCount = channels,
 				FrameCount = frames,
 				SamplesPerFrame = samplesPerFrame,
 				FrameSize = frames * samplesPerFrame
 			};
 		}
 
 		public static void GetLastPacketDuration(IntPtr decoder, out int sampleCount)
 			=> opus_decoder_ctl(decoder, OpusControl.GetLastPacketDuration, out sampleCount);
 	}
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextExtension.cs b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
index 3ab318245..caac30fdb 100644
--- a/DisCatSharp.VoiceNext/VoiceNextExtension.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
@@ -1,265 +1,264 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.VoiceNext.Entities;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.VoiceNext;
 
 /// <summary>
 /// Represents VoiceNext extension, which acts as Discord voice client.
 /// </summary>
 public sealed class VoiceNextExtension : BaseExtension
 {
 	/// <summary>
 	/// Gets or sets the configuration.
 	/// </summary>
 	private readonly VoiceNextConfiguration _configuration;
 
 	/// <summary>
 	/// Gets or sets the active connections.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, VoiceNextConnection> _activeConnections;
 
 	/// <summary>
 	/// Gets or sets the voice state updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> _voiceStateUpdates;
 
 	/// <summary>
 	/// Gets or sets the voice server updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> _voiceServerUpdates;
 
 	/// <summary>
 	/// Gets whether this connection has incoming voice enabled.
 	/// </summary>
 	public bool IsIncomingEnabled { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="VoiceNextExtension"/> class.
 	/// </summary>
 	/// <param name="config">The config.</param>
 	internal VoiceNextExtension(VoiceNextConfiguration config)
 	{
 		this._configuration = new VoiceNextConfiguration(config);
 		this.IsIncomingEnabled = config.EnableIncoming;
 
 		this._activeConnections = new ConcurrentDictionary<ulong, VoiceNextConnection>();
 		this._voiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
 		this._voiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
 	}
 
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 	/// <exception cref="InvalidOperationException"/>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this.Client.VoiceStateUpdated += this.Client_VoiceStateUpdate;
 		this.Client.VoiceServerUpdated += this.Client_VoiceServerUpdate;
 	}
 
 	/// <summary>
 	/// Create a VoiceNext connection for the specified channel.
 	/// </summary>
 	/// <param name="channel">Channel to connect to.</param>
 	/// <returns>VoiceNext connection for this channel.</returns>
 	public async Task<VoiceNextConnection> ConnectAsync(DiscordChannel channel)
 	{
 		if (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Invalid channel specified; needs to be voice or stage channel", nameof(channel));
 
 		if (channel.Guild == null)
 			throw new ArgumentException("Invalid channel specified; needs to be guild channel", nameof(channel));
 
 		if (!channel.PermissionsFor(channel.Guild.CurrentMember).HasPermission(Permissions.AccessChannels | Permissions.UseVoice))
 			throw new InvalidOperationException("You need AccessChannels and UseVoice permission to connect to this voice channel");
 
 		var gld = channel.Guild;
 		if (this._activeConnections.ContainsKey(gld.Id))
 			throw new InvalidOperationException("This guild already has a voice connection");
 
 		var vstut = new TaskCompletionSource<VoiceStateUpdateEventArgs>();
 		var vsrut = new TaskCompletionSource<VoiceServerUpdateEventArgs>();
 		this._voiceStateUpdates[gld.Id] = vstut;
 		this._voiceServerUpdates[gld.Id] = vsrut;
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = gld.Id,
 				ChannelId = channel.Id,
 				Deafened = false,
 				Muted = false
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (channel.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 
 		var vstu = await vstut.Task.ConfigureAwait(false);
 		var vstup = new VoiceStateUpdatePayload
 		{
 			SessionId = vstu.SessionId,
 			UserId = vstu.User.Id
 		};
 		var vsru = await vsrut.Task.ConfigureAwait(false);
 		var vsrup = new VoiceServerUpdatePayload
 		{
 			Endpoint = vsru.Endpoint,
 			GuildId = vsru.Guild.Id,
 			Token = vsru.VoiceToken
 		};
 
 		var vnc = new VoiceNextConnection(this.Client, gld, channel, this._configuration, vsrup, vstup);
 		vnc.VoiceDisconnected += this.Vnc_VoiceDisconnected;
 		await vnc.ConnectAsync().ConfigureAwait(false);
 		await vnc.WaitForReadyAsync().ConfigureAwait(false);
 		this._activeConnections[gld.Id] = vnc;
 		return vnc;
 	}
 
 	/// <summary>
 	/// Gets a VoiceNext connection for specified guild.
 	/// </summary>
 	/// <param name="guild">Guild to get VoiceNext connection for.</param>
 	/// <returns>VoiceNext connection for the specified guild.</returns>
-	public VoiceNextConnection GetConnection(DiscordGuild guild) => this._activeConnections.ContainsKey(guild.Id) ? this._activeConnections[guild.Id] : null;
+	public VoiceNextConnection? GetConnection(DiscordGuild guild) => this._activeConnections.TryGetValue(guild.Id, out var connection) ? connection : null;
 
 	/// <summary>
 	/// Vnc_S the voice disconnected.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <returns>A Task.</returns>
 	private async Task Vnc_VoiceDisconnected(DiscordGuild guild)
 	{
-		VoiceNextConnection vnc = null;
 		if (this._activeConnections.ContainsKey(guild.Id))
-			this._activeConnections.TryRemove(guild.Id, out vnc);
+			this._activeConnections.TryRemove(guild.Id, out _);
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = guild.Id,
 				ChannelId = null
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (guild.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Client_S the voice state update.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private Task Client_VoiceStateUpdate(DiscordClient client, VoiceStateUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (e.User == null)
 			return Task.CompletedTask;
 
 		if (e.User.Id == this.Client.CurrentUser.Id)
 		{
 			if (e.After.Channel == null && this._activeConnections.TryRemove(gld.Id, out var ac))
 				ac.Disconnect();
 
 			if (this._activeConnections.TryGetValue(e.Guild.Id, out var vnc))
 				vnc.TargetChannel = e.Channel;
 
 			if (!string.IsNullOrWhiteSpace(e.SessionId) && e.Channel != null && this._voiceStateUpdates.TryRemove(gld.Id, out var xe))
 				xe.SetResult(e);
 		}
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Client_S the voice server update.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private async Task Client_VoiceServerUpdate(DiscordClient client, VoiceServerUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return;
 
 		if (this._activeConnections.TryGetValue(e.Guild.Id, out var vnc))
 		{
 			vnc.ServerData = new VoiceServerUpdatePayload
 			{
 				Endpoint = e.Endpoint,
 				GuildId = e.Guild.Id,
 				Token = e.VoiceToken
 			};
 
 			var eps = e.Endpoint;
 			var epi = eps.LastIndexOf(':');
 			var eph = string.Empty;
 			var epp = 443;
 			if (epi != -1)
 			{
 				eph = eps[..epi];
 				epp = int.Parse(eps[(epi + 1)..]);
 			}
 			else
 			{
 				eph = eps;
 			}
 			vnc.WebSocketEndpoint = new ConnectionEndpoint { Hostname = eph, Port = epp };
 
 			vnc.Resume = false;
 			await vnc.ReconnectAsync().ConfigureAwait(false);
 		}
 
 		if (this._voiceServerUpdates.ContainsKey(gld.Id))
 		{
 			this._voiceServerUpdates.TryRemove(gld.Id, out var xe);
 			xe.SetResult(e);
 		}
 	}
 }
diff --git a/DisCatSharp.code-workspace b/DisCatSharp.code-workspace
index 5f055bdae..52664b383 100644
--- a/DisCatSharp.code-workspace
+++ b/DisCatSharp.code-workspace
@@ -1,18 +1,20 @@
 {
 	"folders": [
 		{
 			"path": "."
 		}
 	],
 	"settings": {
 		"discord.lowerDetailsEditing": "Editing {file_name}:{current_line}/{total_lines}",
 		"discord.detailsEditing": "Working on {git_repo_name} ({git_branch})",
 		"discord.lowerDetailsDebugging": "Debugging: {file_name}",
 		"discord.detailsDebugging": "Working on {git_repo_name} ({git_branch})",
 		"licenser.author": "Aiko IT Systems",
 		"licenser.customHeader": "This file is part of the DisCatSharp project, a fork of DSharpPlus.\\n\\nCopyright (c) 2021 AITSYS\\n\\nPermission is hereby granted, free of charge, to any person obtaining a copy\\nof this software and associated documentation files (the \"Software\"), to deal\\nin the Software without restriction, including without limitation the rights\\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\ncopies of the Software, and to permit persons to whom the Software is\\nfurnished to do so, subject to the following conditions:\\n\\nThe above copyright notice and this permission notice shall be included in all\\ncopies or substantial portions of the Software.\\n\\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\nSOFTWARE.",
 		"licenser.license": "MIT",
 		"licenser.projectName": "DisCatSharp",
-		"licenser.useSingleLineStyle": false
+		"licenser.useSingleLineStyle": false,
+		"gitlens.views.repositories.showIncomingActivity": true,
+		"gitlens.graph.showRemoteNames": true
 	}
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index 2325338d2..39920a6b5 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1468 +1,1468 @@
 // 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.Exceptions;
 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 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 is ChannelType.Private or 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", 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>
 	[JsonIgnore]
 	public IReadOnlyList<ForumPostTag> AvailableTags => this.InternalAvailableTags;
 
 
 	/// <summary>
 	/// List of available tags for forum posts.
 	/// </summary>
 	[JsonProperty("available_tags", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<ForumPostTag> InternalAvailableTags { get; set; } = new();
 
 	/// <summary>
 	/// List of available tags for forum posts.
 	/// </summary>
 	[JsonProperty("default_reaction_emoji", NullValueHandling = NullValueHandling.Ignore)]
 	public ForumReactionEmoji DefaultReactionEmoji { get; internal set; }
 
 	[JsonProperty("default_sort_order", NullValueHandling = NullValueHandling.Include)]
 	public ForumPostSortOrder? DefaultSortOrder { 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="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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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));
 
 		// TODO: Add forum tags option missing?
 
 		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, this.Flags, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets a specific message.
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <param name="fetch">Whether to bypass the cache. Defaults to false.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> GetMessageAsync(ulong id, bool fetch = false) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& !fetch
 		&& 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>
 	/// Tries to get a specific message.
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <param name="fetch">Whether to bypass the cache. Defaults to true.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage?> TryGetMessageAsync(ulong id, bool fetch = true)
 	{
 		try
 		{
 			return await this.GetMessageAsync(id, fetch).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Modifies the current channel.
 	/// </summary>
 	/// <param name="action">Action to perform on this channel</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 	/// <exception cref="NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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")}.");
 
 		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, mdl.Flags, mdl.AuditLogReason);
 	}
 
 	/// <summary>
 	/// Modifies the current forum channel.
 	/// </summary>
 	/// <param name="action">Action to perform on this channel</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 	/// <exception cref="NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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 && mdl.DefaultAutoArchiveDuration.Value.HasValue)
 			if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value.Value))
 				throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 		return mdl.AvailableTags.HasValue && mdl.AvailableTags.Value.Count > 20
 			? throw new NotSupportedException("Cannot have more than 20 tags in a forum channel.")
 			: (Task)this.Discord.ApiClient.ModifyForumChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Template, mdl.Nsfw,
 			mdl.Parent.Map(p => p?.Id), mdl.AvailableTags, mdl.DefaultReactionEmoji, mdl.PerUserRateLimit, mdl.PostCreateUserRateLimit,
 			mdl.DefaultSortOrder, mdl.DefaultAutoArchiveDuration, mdl.PermissionOverwrites, mdl.Flags, 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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 	/// <exception cref="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();
 	}
 
 	internal void Initialize(BaseDiscordClient client)
 	{
 		this.Discord = client;
 		foreach (var xo in this.PermissionOverwritesInternal)
 		{
 			xo.Discord = this.Discord;
 			xo.ChannelId = this.Id;
 		}
 		if (this.InternalAvailableTags != null)
 		{
 			foreach (var xo in this.InternalAvailableTags)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = this.Id;
 				xo.Channel = this;
 			}
 		}
 	}
 
 	/// <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.Initialize(this.Discord);
 			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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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?.Id;
 					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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="BadRequestException"/> error.
 	/// </summary>
 	/// <param name="messages">A collection of messages to delete.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="targetApplicationId">The target activity ID. 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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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, ulong? targetApplicationId = null, ulong? targetUser = null, string reason = null)
 		=> this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, maxAge, maxUses, targetType, targetApplicationId, 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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or <see cref="Permissions.UseVoice"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="NotFoundException">Thrown when the resource does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="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="NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="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>
+	/// <exception cref="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="GuildFeaturesEnum.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, isForum: false, reason: 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, isForum: false, reason: reason)
 						: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 	/// <summary>
 	/// Creates a forum post.
 	/// </summary>
 	/// <param name="name">The name of the post.</param>
 	/// <param name="builder">The message of the post.</param>
 	/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 	/// <param name="tags">The tags to add on creation.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <returns>The created thread.</returns>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadChannel> CreatePostAsync(string name, DiscordMessageBuilder builder, int? rateLimitPerUser = null, IEnumerable<ForumPostTag>? tags = null, string reason = null)
 		=> this.Type != ChannelType.Forum ? throw new NotSupportedException("Parent channel must be forum.") : await this.Discord.ApiClient.CreateThreadAsync(this.Id, null, name, null, null, rateLimitPerUser, tags, builder, true, reason);
 
 	/// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> or <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetPrivateArchivedThreadsAsync(this.Id, before, limit);
 
 	/// <summary>
 	/// Gets a forum channel tag.
 	/// </summary>
 	/// <param name="id">The id of the tag to get.</param>
 	/// <exception cref="InvalidOperationException">Thrown when the tag does not exist.</exception>
 	public ForumPostTag GetForumPostTag(ulong id)
 	{
 		var tag = this.InternalAvailableTags.First(x => x.Id == id);
 		tag.Discord = this.Discord;
 		tag.ChannelId = this.Id;
 		tag.Channel = this;
 		return tag;
 	}
 
 	/// <summary>
 	/// Tries to get a forum channel tag.
 	/// </summary>
 	/// <param name="id">The id of the tag to get or null if not found.</param>
 	public ForumPostTag? TryGetForumPostTag(ulong id)
 	{
 		var tag = this.InternalAvailableTags.FirstOrDefault(x => x.Id == id);
 		if (tag is not null)
 		{
 			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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the tag does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> CreateForumPostTagAsync(string name, DiscordEmoji emoji = null, bool moderated = false, string reason = null)
 		=> this.Type != ChannelType.Forum ? throw new NotSupportedException("Channel needs to be type of Forum") :
 		this.AvailableTags.Count == 20 ?
 		throw new NotSupportedException("Cannot have more than 20 tags in a forum channel.") :
 		await this.Discord.ApiClient.ModifyForumChannelAsync(this.Id, null, null, Optional.None, Optional.None, null, Optional.None, this.InternalAvailableTags.Append(new ForumPostTag()
 		{
 			Name = name,
 			EmojiId = emoji != null && emoji.Id != 0 ? emoji.Id : null,
 			UnicodeEmojiString = emoji?.Id == null || emoji?.Id == 0 ? emoji?.Name ?? null : null,
 			Moderated = moderated,
 			Id = null
 		}).ToList(), Optional.None, Optional.None, Optional.None, Optional.None, Optional.None, null, Optional.None, 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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the tag does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> DeleteForumPostTag(ulong id, string reason = null)
 		=> this.Type != ChannelType.Forum ? throw new NotSupportedException("Channel needs to be type of Forum") : await this.Discord.ApiClient.ModifyForumChannelAsync(this.Id, null, null, Optional.None, Optional.None, null, Optional.None, this.InternalAvailableTags?.Where(x => x.Id != id)?.ToList(), Optional.None, Optional.None, Optional.None, Optional.None, Optional.None, null, Optional.None, 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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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)
 		=> await this.Discord.ApiClient.CreateWebhookAsync(this.IsThread() ? this.ParentId!.Value : this.Id, name,
 			ImageTool.Base64FromStream(avatar), reason).ConfigureAwait(false);
 
 	/// <summary>
 	/// Returns a list of webhooks.
 	/// </summary>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 		=> this.Discord.ApiClient.GetChannelWebhooksAsync(this.IsThread() ? this.ParentId!.Value : this.Id);
 
 	/// <summary>
 	/// Moves a member to this voice channel.
 	/// </summary>
 	/// <param name="member">The member to be moved.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exists or if the Member does not exists.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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="ArgumentException">Thrown when trying to follow a non-news channel.</exception>
 	/// <exception cref="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="ArgumentException">Thrown when the message has already been crossposted.</exception>
 	/// <exception cref="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="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/Color/DiscordColor.cs b/DisCatSharp/Entities/Color/DiscordColor.cs
index 0a0c4ef97..ff771c5bb 100644
--- a/DisCatSharp/Entities/Color/DiscordColor.cs
+++ b/DisCatSharp/Entities/Color/DiscordColor.cs
@@ -1,129 +1,129 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Linq;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a color used in Discord API.
 /// </summary>
-public partial struct DiscordColor
+public readonly partial struct DiscordColor
 {
 	private static readonly char[] s_hexAlphabet = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
 	/// <summary>
 	/// Gets the integer representation of this color.
 	/// </summary>
 	public int Value { get; }
 
 	/// <summary>
 	/// Gets the red component of this color as an 8-bit integer.
 	/// </summary>
 	public byte R
 		=> (byte)((this.Value >> 16) & 0xFF);
 
 	/// <summary>
 	/// Gets the green component of this color as an 8-bit integer.
 	/// </summary>
 	public byte G
 		=> (byte)((this.Value >> 8) & 0xFF);
 
 	/// <summary>
 	/// Gets the blue component of this color as an 8-bit integer.
 	/// </summary>
 	public byte B
 		=> (byte)(this.Value & 0xFF);
 
 	/// <summary>
 	/// Creates a new color with specified value.
 	/// </summary>
 	/// <param name="color">Value of the color.</param>
 	public DiscordColor(int color)
 	{
 		this.Value = color;
 	}
 
 	/// <summary>
 	/// Creates a new color with specified values for red, green, and blue components.
 	/// </summary>
 	/// <param name="r">Value of the red component.</param>
 	/// <param name="g">Value of the green component.</param>
 	/// <param name="b">Value of the blue component.</param>
 	public DiscordColor(byte r, byte g, byte b)
 	{
 		this.Value = (r << 16) | (g << 8) | b;
 	}
 
 	/// <summary>
 	/// Creates a new color with specified values for red, green, and blue components.
 	/// </summary>
 	/// <param name="r">Value of the red component.</param>
 	/// <param name="g">Value of the green component.</param>
 	/// <param name="b">Value of the blue component.</param>
 	public DiscordColor(float r, float g, float b)
 	{
 		if (r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1)
 			throw new ArgumentOutOfRangeException(null, "Each component must be between 0.0 and 1.0 inclusive.");
 
 		var rb = (byte)(r * 255);
 		var gb = (byte)(g * 255);
 		var bb = (byte)(b * 255);
 
 		this.Value = (rb << 16) | (gb << 8) | bb;
 	}
 
 	/// <summary>
 	/// Creates a new color from specified string representation.
 	/// </summary>
 	/// <param name="color">String representation of the color. Must be 6 hexadecimal characters, optionally with # prefix.</param>
 	public DiscordColor(string color)
 	{
 		if (string.IsNullOrWhiteSpace(color))
 			throw new ArgumentNullException(nameof(color), "Null or empty values are not allowed!");
 
 		if (color.Length != 6 && color.Length != 7)
 			throw new ArgumentException("Color must be 6 or 7 characters in length.", nameof(color));
 
 		color = color.ToUpper();
 		if (color.Length == 7 && color[0] != '#')
 			throw new ArgumentException("7-character colors must begin with #.", nameof(color));
 		else if (color.Length == 7)
 			color = color[1..];
 
 		if (color.Any(xc => !s_hexAlphabet.Contains(xc)))
 			throw new ArgumentException("Colors must consist of hexadecimal characters only.", nameof(color));
 
 		this.Value = int.Parse(color, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets a string representation of this color.
 	/// </summary>
 	/// <returns>String representation of this color.</returns>
 	public override string ToString() => $"#{this.Value:X6}";
 
 	public static implicit operator DiscordColor(int value)
 		=> new(value);
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
index 4a94b5515..f21bf3c5b 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
@@ -1,1322 +1,1322 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities;
 
 public partial class DiscordGuild
 {
 	// TODO: Rework audit logs!
 	/// <summary>
 	/// Gets audit log entries for this guild.
 	/// </summary>
 	/// <param name="limit">Maximum number of entries to fetch.</param>
 	/// <param name="byMember">Filter by member responsible.</param>
 	/// <param name="actionType">Filter by action type.</param>
 	/// <returns>A collection of requested audit log entries.</returns>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember byMember = null, AuditLogActionType? actionType = null)
 	{
 		var alrs = new List<AuditLog>();
 		int ac = 1, tc = 0, rmn = 100;
 		var last = 0ul;
 		while (ac > 0)
 		{
 			rmn = limit != null ? limit.Value - tc : 100;
 			rmn = Math.Min(100, rmn);
 			if (rmn <= 0) break;
 
 			var alr = await this.Discord.ApiClient.GetAuditLogsAsync(this.Id, rmn, null, last == 0 ? null : last, byMember?.Id, (int?)actionType).ConfigureAwait(false);
 			ac = alr.Entries.Count;
 			tc += ac;
 			if (ac > 0)
 			{
 				last = alr.Entries[alr.Entries.Count - 1].Id;
 				alrs.Add(alr);
 			}
 		}
 
 		var amr = alrs.SelectMany(xa => xa.Users)
 			.GroupBy(xu => xu.Id)
 			.Select(xgu => xgu.First());
 
 		foreach (var xau in amr)
 		{
 			if (this.Discord.UserCache.ContainsKey(xau.Id))
 				continue;
 
 			var xtu = new TransportUser
 			{
 				Id = xau.Id,
 				Username = xau.Username,
 				Discriminator = xau.Discriminator,
 				AvatarHash = xau.AvatarHash
 			};
 			var xu = new DiscordUser(xtu) { Discord = this.Discord };
 			xu = this.Discord.UserCache.AddOrUpdate(xu.Id, xu, (id, old) =>
 			{
 				old.Username = xu.Username;
 				old.Discriminator = xu.Discriminator;
 				old.AvatarHash = xu.AvatarHash;
 				return old;
 			});
 		}
 
 		var atgse = alrs.SelectMany(xa => xa.ScheduledEvents)
 			.GroupBy(xse => xse.Id)
 			.Select(xgse => xgse.First());
 
 		var ath = alrs.SelectMany(xa => xa.Threads)
 			.GroupBy(xt => xt.Id)
 			.Select(xgt => xgt.First());
 
 		var aig = alrs.SelectMany(xa => xa.Integrations)
 			.GroupBy(xi => xi.Id)
 			.Select(xgi => xgi.First());
 
 		var ahr = alrs.SelectMany(xa => xa.Webhooks)
 			.GroupBy(xh => xh.Id)
 			.Select(xgh => xgh.First());
 
 		var ams = amr.Select(xau => this.MembersInternal != null && this.MembersInternal.TryGetValue(xau.Id, out var member) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, GuildId = this.Id });
 		var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
 #pragma warning disable CS0219
 		Dictionary<ulong, DiscordThreadChannel> dtc = null;
 		Dictionary<ulong, DiscordIntegration> di = null;
 		Dictionary<ulong, DiscordScheduledEvent> dse = null;
 #pragma warning restore
 
 		Dictionary<ulong, DiscordWebhook> ahd = null;
 		if (ahr.Any())
 		{
 			var whr = await this.GetWebhooksAsync().ConfigureAwait(false);
 			var whs = whr.ToDictionary(xh => xh.Id, xh => xh);
 
 			var amh = ahr.Select(xah => whs.TryGetValue(xah.Id, out var webhook) ? webhook : new DiscordWebhook { Discord = this.Discord, Name = xah.Name, Id = xah.Id, AvatarHash = xah.AvatarHash, ChannelId = xah.ChannelId, GuildId = xah.GuildId, Token = xah.Token });
 			ahd = amh.ToDictionary(xh => xh.Id, xh => xh);
 		}
 
 		var acs = alrs.SelectMany(xa => xa.Entries).OrderByDescending(xa => xa.Id);
 		var entries = new List<DiscordAuditLogEntry>();
 		foreach (var xac in acs)
 		{
 			DiscordAuditLogEntry entry = null;
 			ulong t1, t2;
 			int t3, t4;
 			long t5, t6;
 			bool p1, p2;
 			switch (xac.ActionType)
 			{
 				case AuditLogActionType.Invalid:
 					break;
 
 				case AuditLogActionType.GuildUpdate:
 					entry = new DiscordAuditLogGuildEntry
 					{
 						Target = this
 					};
 
 					var entrygld = entry as DiscordAuditLogGuildEntry;
 					foreach (var xc in xac.Changes)
 					{
 						PropertyChange<DiscordChannel> GetChannelChange()
 						{
 							ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 							ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 							return new PropertyChange<DiscordChannel>
 							{
 								Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 							};
 						}
 
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrygld.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "owner_id":
 								entrygld.OwnerChange = new PropertyChange<DiscordMember>
 								{
 									Before = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.OldValueUlong, out var oldMember) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
 									After = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.NewValueUlong, out var newMember) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
 								};
 								break;
 
 							case "icon_hash":
 								entrygld.IconChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.OldValueString}.webp" : null,
 									After = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.NewValueString}.webp" : null
 								};
 								break;
 
 							case "verification_level":
 								entrygld.VerificationLevelChange = new PropertyChange<VerificationLevel>
 								{
 									Before = (VerificationLevel)(long)xc.OldValue,
 									After = (VerificationLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "afk_channel_id":
 								entrygld.AfkChannelChange = GetChannelChange();
 								break;
 
 							case "system_channel_flags":
 								entrygld.SystemChannelFlagsChange = new PropertyChange<SystemChannelFlags>()
 								{
 									Before = (SystemChannelFlags)(long)xc.OldValue,
 									After = (SystemChannelFlags)(long)xc.NewValue
 								};
 								break;
 
 							case "widget_channel_id":
 								entrygld.WidgetChannelChange = GetChannelChange();
 								break;
 
 							case "rules_channel_id":
 								entrygld.RulesChannelChange = GetChannelChange();
 								break;
 
 							case "public_updates_channel_id":
 								entrygld.PublicUpdatesChannelChange = GetChannelChange();
 								break;
 
 							case "splash_hash":
 								entrygld.SplashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.OldValueString}.webp?size=2048" : null,
 									After = xc.NewValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.NewValueString}.webp?size=2048" : null
 								};
 								break;
 
 							case "default_message_notifications":
 								entrygld.NotificationSettingsChange = new PropertyChange<DefaultMessageNotifications>
 								{
 									Before = (DefaultMessageNotifications)(long)xc.OldValue,
 									After = (DefaultMessageNotifications)(long)xc.NewValue
 								};
 								break;
 
 							case "system_channel_id":
 								entrygld.SystemChannelChange = GetChannelChange();
 								break;
 
 							case "explicit_content_filter":
 								entrygld.ExplicitContentFilterChange = new PropertyChange<ExplicitContentFilter>
 								{
 									Before = (ExplicitContentFilter)(long)xc.OldValue,
 									After = (ExplicitContentFilter)(long)xc.NewValue
 								};
 								break;
 
 							case "mfa_level":
 								entrygld.MfaLevelChange = new PropertyChange<MfaLevel>
 								{
 									Before = (MfaLevel)(long)xc.OldValue,
 									After = (MfaLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "region":
 								entrygld.RegionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "vanity_url_code":
 								entrygld.VanityUrlCodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "premium_progress_bar_enabled":
 								entrygld.PremiumProgressBarChange = new PropertyChange<bool>
 								{
 									Before = (bool)xc.OldValue,
 									After = (bool)xc.NewValue
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ChannelCreate:
 				case AuditLogActionType.ChannelDelete:
 				case AuditLogActionType.ChannelUpdate:
 					entry = new DiscordAuditLogChannelEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value) ?? new DiscordChannel { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrychn = entry as DiscordAuditLogChannelEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrychn.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrychn.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "flags":
 								entrychn.ChannelFlagsChange = new PropertyChange<ChannelFlags>()
 								{
 									Before = (ChannelFlags)(long)(xc.OldValue ?? 0L),
 									After = (ChannelFlags)(long)(xc.NewValue ?? 0L)
 								};
 								break;
 
 							case "permission_overwrites":
 								var olds = xc.OldValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								var news = xc.NewValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								entrychn.OverwriteChange = new PropertyChange<IReadOnlyList<DiscordOverwrite>>
 								{
 									Before = olds != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(olds)) : null,
 									After = news != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(news)) : null
 								};
 								break;
 
 							case "topic":
 								entrychn.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "nsfw":
 								entrychn.NsfwChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "rtc_region":
 								entrychn.RtcRegionIdChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "bitrate":
 								entrychn.BitrateChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "user_limit":
 								entrychn.UserLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrychn.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "default_auto_archive_duration":
 								entrychn.DefaultAutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = (ThreadAutoArchiveDuration?)(long?)xc.OldValue,
 									After = (ThreadAutoArchiveDuration?)(long?)xc.NewValue
 								};
 								break;
 							case "available_tags":
 								var oldTags = xc.OldValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<ForumPostTag>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								var newTags = xc.NewValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<ForumPostTag>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								entrychn.AvailableTagsChange = new PropertyChange<List<ForumPostTag>>
 								{
 									Before = oldTags != null ? new List<ForumPostTag>(new List<ForumPostTag>(oldTags)) : null,
 									After = newTags != null ? new List<ForumPostTag>(new List<ForumPostTag>(newTags)) : null
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.OverwriteCreate:
 				case AuditLogActionType.OverwriteDelete:
 				case AuditLogActionType.OverwriteUpdate:
 					entry = new DiscordAuditLogOverwriteEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value)?.PermissionOverwrites.FirstOrDefault(xo => xo.Id == xac.Options.Id),
 						Channel = this.GetChannel(xac.TargetId.Value)
 					};
 
 					var entryovr = entry as DiscordAuditLogOverwriteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "deny":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.DenyChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "allow":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.AllowChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "type":
 								entryovr.TypeChange = new PropertyChange<OverwriteType?>
 								{
 									Before = xc.OldValue != null ? (OverwriteType)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (OverwriteType)(long)xc.NewValue : null
 								};
 								break;
 
 							case "id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.TargetIdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? t1 : null,
 									After = p2 ? t2 : null
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.Kick:
 					entry = new DiscordAuditLogKickEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var kickMember) ? kickMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.Prune:
 					entry = new DiscordAuditLogPruneEntry
 					{
 						Days = xac.Options.DeleteMemberDays,
 						Toll = xac.Options.MembersRemoved
 					};
 					break;
 
 				case AuditLogActionType.Ban:
 				case AuditLogActionType.Unban:
 					entry = new DiscordAuditLogBanEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var unbanMember) ? unbanMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.MemberUpdate:
 				case AuditLogActionType.MemberRoleUpdate:
 					entry = new DiscordAuditLogMemberUpdateEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var roleUpdMember) ? roleUpdMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrymbu = entry as DiscordAuditLogMemberUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "nick":
 								entrymbu.NicknameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "deaf":
 								entrymbu.DeafenChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "mute":
 								entrymbu.MuteChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "communication_disabled_until":
 								entrymbu.CommunicationDisabledUntilChange = new PropertyChange<DateTime?>
 								{
 									Before = (DateTime?)xc.OldValue,
 									After = (DateTime?)xc.NewValue
 								};
 								break;
 
 							case "$add":
 								entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							case "$remove":
 								entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.RoleCreate:
 				case AuditLogActionType.RoleDelete:
 				case AuditLogActionType.RoleUpdate:
 					entry = new DiscordAuditLogRoleUpdateEntry
 					{
 						Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryrol.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "color":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryrol.ColorChange = new PropertyChange<int?>
 								{
 									Before = p1 ? t3 : null,
 									After = p2 ? t4 : null
 								};
 								break;
 
 							case "permissions":
 								entryrol.PermissionChange = new PropertyChange<Permissions?>
 								{
 									Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
 									After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
 								};
 								break;
 
 							case "position":
 								entryrol.PositionChange = new PropertyChange<int?>
 								{
 									Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
 								};
 								break;
 
 							case "mentionable":
 								entryrol.MentionableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "hoist":
 								entryrol.HoistChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "icon_hash":
 								entryrol.IconHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.InviteCreate:
 				case AuditLogActionType.InviteDelete:
 				case AuditLogActionType.InviteUpdate:
 					entry = new DiscordAuditLogInviteEntry();
 
 					var inv = new DiscordInvite
 					{
 						Discord = this.Discord,
 						Guild = new DiscordInviteGuild
 						{
 							Discord = this.Discord,
 							Id = this.Id,
 							Name = this.Name,
 							SplashHash = this.SplashHash
 						}
 					};
 
 					var entryinv = entry as DiscordAuditLogInviteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "max_age":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxAgeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? t3 : null,
 									After = p2 ? t4 : null
 								};
 								break;
 
 							case "code":
 								inv.Code = xc.OldValueString ?? xc.NewValueString;
 
 								entryinv.CodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "temporary":
 								entryinv.TemporaryChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "inviter_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.InviterChange = new PropertyChange<DiscordMember>
 								{
 									Before = amd.TryGetValue(t1, out var propBeforeMember) ? propBeforeMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 									After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 
 								var ch = entryinv.ChannelChange.Before ?? entryinv.ChannelChange.After;
 								var cht = ch?.Type;
 								inv.Channel = new DiscordInviteChannel
 								{
 									Discord = this.Discord,
 									Id = p1 ? t1 : t2,
 									Name = ch?.Name,
 									Type = cht != null ? cht.Value : ChannelType.Unknown
 								};
 								break;
 
 							case "uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.UsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? t3 : null,
 									After = p2 ? t4 : null
 								};
 								break;
 
 							case "max_uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxUsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? t3 : null,
 									After = p2 ? t4 : null
 								};
 								break;
 
 							// TODO: Add changes for target application
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 
 					entryinv.Target = inv;
 					break;
 
 				case AuditLogActionType.WebhookCreate:
 				case AuditLogActionType.WebhookDelete:
 				case AuditLogActionType.WebhookUpdate:
 					entry = new DiscordAuditLogWebhookEntry
 					{
 						Target = ahd.TryGetValue(xac.TargetId.Value, out var webhook) ? webhook : new DiscordWebhook { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrywhk = entry as DiscordAuditLogWebhookEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "application_id": // ???
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.IdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? t1 : null,
 									After = p2 ? t2 : null
 								};
 								break;
 
 							case "name":
 								entrywhk.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 								break;
 
 							case "type": // ???
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entrywhk.TypeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? t3 : null,
 									After = p2 ? t4 : null
 								};
 								break;
 
 							case "avatar_hash":
 								entrywhk.AvatarHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.EmojiCreate:
 				case AuditLogActionType.EmojiDelete:
 				case AuditLogActionType.EmojiUpdate:
 					entry = new DiscordAuditLogEmojiEntry
 					{
 						Target = this.EmojisInternal.TryGetValue(xac.TargetId.Value, out var target) ? target : new DiscordEmoji { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryemo = entry as DiscordAuditLogEmojiEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryemo.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StageInstanceCreate:
 				case AuditLogActionType.StageInstanceDelete:
 				case AuditLogActionType.StageInstanceUpdate:
 					entry = new DiscordAuditLogStageEntry
 					{
 						Target = this.StageInstancesInternal.TryGetValue(xac.TargetId.Value, out var stage) ? stage : new DiscordStageInstance { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysta = entry as DiscordAuditLogStageEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "topic":
 								entrysta.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "privacy_level":
 								entrysta.PrivacyLevelChange = new PropertyChange<StagePrivacyLevel?>
 								{
 									Before = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5) ? (StagePrivacyLevel?)t5 : null,
 									After = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6) ? (StagePrivacyLevel?)t6 : null,
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StickerCreate:
 				case AuditLogActionType.StickerDelete:
 				case AuditLogActionType.StickerUpdate:
 					entry = new DiscordAuditLogStickerEntry
 					{
 						Target = this.StickersInternal.TryGetValue(xac.TargetId.Value, out var sticker) ? sticker : new DiscordSticker { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysti = entry as DiscordAuditLogStickerEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrysti.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "description":
 								entrysti.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "tags":
 								entrysti.TagsChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "guild_id":
 								entrysti.GuildIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 							case "available":
 								entrysti.AvailabilityChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue,
 								};
 								break;
 							case "asset":
 								entrysti.AssetChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "id":
 								entrysti.IdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var oid) ? oid : null,
 									After = ulong.TryParse(xc.NewValueString, out var nid) ? nid : null
 								};
 								break;
 							case "type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.TypeChange = new PropertyChange<StickerType?>
 								{
 									Before = p1 ? (StickerType?)t5 : null,
 									After = p2 ? (StickerType?)t6 : null
 								};
 								break;
 							case "format_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.FormatChange = new PropertyChange<StickerFormat?>
 								{
 									Before = p1 ? (StickerFormat?)t5 : null,
 									After = p2 ? (StickerFormat?)t6 : null
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 
 				case AuditLogActionType.MessageDelete:
 				case AuditLogActionType.MessageBulkDelete:
 				{
 					entry = new DiscordAuditLogMessageEntry();
 
 					var entrymsg = entry as DiscordAuditLogMessageEntry;
 
 					if (xac.Options != null)
 					{
 						entrymsg.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrymsg.MessageCount = xac.Options.Count;
 					}
 
 					if (entrymsg.Channel != null)
 					{
 						entrymsg.Target = this.Discord is DiscordClient dc
 							&& dc.MessageCache != null
 							&& dc.MessageCache.TryGet(xm => xm.Id == xac.TargetId.Value && xm.ChannelId == entrymsg.Channel.Id, out var msg)
 							? msg
 							: new DiscordMessage { Discord = this.Discord, Id = xac.TargetId.Value };
 					}
 					break;
 				}
 
 				case AuditLogActionType.MessagePin:
 				case AuditLogActionType.MessageUnpin:
 				{
 					entry = new DiscordAuditLogMessagePinEntry();
 
 					var entrypin = entry as DiscordAuditLogMessagePinEntry;
 
 					if (this.Discord is not DiscordClient dc)
 					{
 						break;
 					}
 
 					if (xac.Options != null)
 					{
 						DiscordMessage message = default;
 						dc.MessageCache?.TryGet(x => x.Id == xac.Options.MessageId && x.ChannelId == xac.Options.ChannelId, out message);
 
 						entrypin.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrypin.Message = message ?? new DiscordMessage { Id = xac.Options.MessageId, Discord = this.Discord };
 					}
 
 					if (xac.TargetId.HasValue)
 					{
 						dc.UserCache.TryGetValue(xac.TargetId.Value, out var user);
 						entrypin.Target = user ?? new DiscordUser { Id = user.Id, Discord = this.Discord };
 					}
 
 					break;
 				}
 
 				case AuditLogActionType.BotAdd:
 				{
 					entry = new DiscordAuditLogBotAddEntry();
 
 					if (!(this.Discord is DiscordClient dc && xac.TargetId.HasValue))
 					{
 						break;
 					}
 
 					dc.UserCache.TryGetValue(xac.TargetId.Value, out var bot);
 					(entry as DiscordAuditLogBotAddEntry).TargetBot = bot ?? new DiscordUser { Id = xac.TargetId.Value, Discord = this.Discord };
 
 					break;
 				}
 
 				case AuditLogActionType.MemberMove:
 					entry = new DiscordAuditLogMemberMoveEntry();
 
 					if (xac.Options == null)
 					{
 						break;
 					}
 
 					var moveentry = entry as DiscordAuditLogMemberMoveEntry;
 
 					moveentry.UserCount = xac.Options.Count;
 					moveentry.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 					break;
 
 				case AuditLogActionType.MemberDisconnect:
 					entry = new DiscordAuditLogMemberDisconnectEntry
 					{
 						UserCount = xac.Options?.Count ?? 0
 					};
 					break;
 
 				case AuditLogActionType.IntegrationCreate:
 				case AuditLogActionType.IntegrationDelete:
 				case AuditLogActionType.IntegrationUpdate:
 					entry = new DiscordAuditLogIntegrationEntry();
 
 					var integentry = entry as DiscordAuditLogIntegrationEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "type":
 								integentry.Type = new PropertyChange<string>()
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "enable_emoticons":
 								integentry.EnableEmoticons = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "expire_behavior":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 							case "expire_grace_period":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ThreadCreate:
 				case AuditLogActionType.ThreadDelete:
 				case AuditLogActionType.ThreadUpdate:
 					entry = new DiscordAuditLogThreadEntry
 					{
 						Target = this.ThreadsInternal.TryGetValue(xac.TargetId.Value, out var thread) ? thread : new DiscordThreadChannel { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrythr = entry as DiscordAuditLogThreadEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrythr.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrythr.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "archived":
 								entrythr.ArchivedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "locked":
 								entrythr.LockedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "invitable":
 								entrythr.InvitableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "auto_archive_duration":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entrythr.AutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = p1 ? (ThreadAutoArchiveDuration?)t5 : null,
 									After = p2 ? (ThreadAutoArchiveDuration?)t6 : null
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrythr.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 				case AuditLogActionType.GuildScheduledEventCreate:
 				case AuditLogActionType.GuildScheduledEventDelete:
 				case AuditLogActionType.GuildScheduledEventUpdate:
 					entry = new DiscordAuditLogGuildScheduledEventEntry
 					{
 						Target = this.ScheduledEventsInternal.TryGetValue(xac.TargetId.Value, out var scheduledEvent) ? scheduledEvent : new DiscordScheduledEvent { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryse = entry as DiscordAuditLogGuildScheduledEventEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "channel_id":
 								entryse.ChannelIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 
 							case "name":
 								entryse.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "description":
 								entryse.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "location":
 								entryse.LocationChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "privacy_level":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.PrivacyLevelChange = new PropertyChange<ScheduledEventPrivacyLevel?>
 								{
 									Before = p1 ? (ScheduledEventPrivacyLevel?)t5 : null,
 									After = p2 ? (ScheduledEventPrivacyLevel?)t6 : null
 								};
 								break;
 
 							case "entity_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.EntityTypeChange = new PropertyChange<ScheduledEventEntityType?>
 								{
 									Before = p1 ? (ScheduledEventEntityType?)t5 : null,
 									After = p2 ? (ScheduledEventEntityType?)t6 : null
 								};
 								break;
 
 							case "status":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.StatusChange = new PropertyChange<ScheduledEventStatus?>
 								{
 									Before = p1 ? (ScheduledEventStatus?)t5 : null,
 									After = p2 ? (ScheduledEventStatus?)t6 : null
 								};
 								break;
 
 							default:
-								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {0} - this should be reported to library developers", xc.Key);
+								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {key} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				// TODO: Handle ApplicationCommandPermissionUpdate
 				case AuditLogActionType.ApplicationCommandPermissionUpdate:
 					break;
 
 				default:
-					this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {0} - this should be reported to library developers", (int)xac.ActionType);
+					this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {key} - this should be reported to library developers", (int)xac.ActionType);
 					break;
 			}
 
 			if (entry == null)
 				continue;
 
 			entry.ActionCategory = xac.ActionType switch
 			{
 				AuditLogActionType.ChannelCreate or AuditLogActionType.EmojiCreate or AuditLogActionType.InviteCreate or AuditLogActionType.OverwriteCreate or AuditLogActionType.RoleCreate or AuditLogActionType.WebhookCreate or AuditLogActionType.IntegrationCreate or AuditLogActionType.StickerCreate or AuditLogActionType.StageInstanceCreate or AuditLogActionType.ThreadCreate or AuditLogActionType.GuildScheduledEventCreate => AuditLogActionCategory.Create,
 				AuditLogActionType.ChannelDelete or AuditLogActionType.EmojiDelete or AuditLogActionType.InviteDelete or AuditLogActionType.MessageDelete or AuditLogActionType.MessageBulkDelete or AuditLogActionType.OverwriteDelete or AuditLogActionType.RoleDelete or AuditLogActionType.WebhookDelete or AuditLogActionType.IntegrationDelete or AuditLogActionType.StickerDelete or AuditLogActionType.StageInstanceDelete or AuditLogActionType.ThreadDelete or AuditLogActionType.GuildScheduledEventDelete => AuditLogActionCategory.Delete,
 				AuditLogActionType.ChannelUpdate or AuditLogActionType.EmojiUpdate or AuditLogActionType.InviteUpdate or AuditLogActionType.MemberRoleUpdate or AuditLogActionType.MemberUpdate or AuditLogActionType.OverwriteUpdate or AuditLogActionType.RoleUpdate or AuditLogActionType.WebhookUpdate or AuditLogActionType.IntegrationUpdate or AuditLogActionType.StickerUpdate or AuditLogActionType.StageInstanceUpdate or AuditLogActionType.ThreadUpdate or AuditLogActionType.GuildScheduledEventUpdate => AuditLogActionCategory.Update,
 				_ => AuditLogActionCategory.Other,
 			};
 			entry.Discord = this.Discord;
 			entry.ActionType = xac.ActionType;
 			entry.Id = xac.Id;
 			entry.Reason = xac.Reason;
 			entry.UserResponsible = amd[xac.UserId];
 			entries.Add(entry);
 		}
 
 		return new ReadOnlyCollection<DiscordAuditLogEntry>(entries);
 	}
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index 8b3c0baaa..fdaaaac50 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5675 +1,5675 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net;
 
 /// <summary>
 /// Represents a discord api client.
 /// </summary>
 public sealed class DiscordApiClient
 {
 	/// <summary>
 	/// The audit log reason header name.
 	/// </summary>
 	private const string REASON_HEADER_NAME = "X-Audit-Log-Reason";
 
 	/// <summary>
 	/// Gets the discord client.
 	/// </summary>
 	internal BaseDiscordClient Discord { get; }
 
 	/// <summary>
 	/// Gets the rest client.
 	/// </summary>
 	internal RestClient Rest { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	internal DiscordApiClient(BaseDiscordClient client)
 	{
 		this.Discord = client;
 		this.Rest = new RestClient(client);
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 	/// </summary>
 	/// <param name="proxy">The proxy.</param>
 	/// <param name="timeout">The timeout.</param>
 	/// <param name="useRelativeRateLimit">If true, use relative rate limit.</param>
 	/// <param name="logger">The logger.</param>
 	internal DiscordApiClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRateLimit, ILogger logger) // This is for meta-clients, such as the webhook client
 	{
 		this.Rest = new RestClient(proxy, timeout, useRelativeRateLimit, logger);
 	}
 
 	/// <summary>
 	/// Builds the query string.
 	/// </summary>
 	/// <param name="values">The values.</param>
 	/// <param name="post">Whether this query will be transmitted via POST.</param>
 	private static string BuildQueryString(IDictionary<string, string> values, bool post = false)
 	{
 		if (values == null || values.Count == 0)
 			return string.Empty;
 
 		var valsCollection = values.Select(xkvp =>
 			$"{WebUtility.UrlEncode(xkvp.Key)}={WebUtility.UrlEncode(xkvp.Value)}");
 		var vals = string.Join("&", valsCollection);
 
 		return !post ? $"?{vals}" : vals;
 	}
 
 	/// <summary>
 	/// Prepares the message.
 	/// </summary>
 	/// <param name="msgRaw">The msg_raw.</param>
 	/// <returns>A DiscordMessage.</returns>
 	private DiscordMessage PrepareMessage(JToken msgRaw)
 	{
 		var author = msgRaw["author"].ToObject<TransportUser>();
 		var ret = msgRaw.ToDiscordObject<DiscordMessage>();
 		ret.Discord = this.Discord;
 
 		this.PopulateMessage(author, ret);
 
 		var referencedMsg = msgRaw["referenced_message"];
 		if (ret.MessageType == MessageType.Reply && !string.IsNullOrWhiteSpace(referencedMsg?.ToString()))
 		{
 			author = referencedMsg["author"].ToObject<TransportUser>();
 			ret.ReferencedMessage.Discord = this.Discord;
 			this.PopulateMessage(author, ret.ReferencedMessage);
 		}
 
 		if (ret.Channel != null)
 			return ret;
 
 		var channel = !ret.GuildId.HasValue
 			? new DiscordDmChannel
 			{
 				Id = ret.ChannelId,
 				Discord = this.Discord,
 				Type = ChannelType.Private
 			}
 			: new DiscordChannel
 			{
 				Id = ret.ChannelId,
 				GuildId = ret.GuildId,
 				Discord = this.Discord
 			};
 
 		ret.Channel = channel;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Populates the message.
 	/// </summary>
 	/// <param name="author">The author.</param>
 	/// <param name="ret">The message.</param>
 	private void PopulateMessage(TransportUser author, DiscordMessage ret)
 	{
 		var guild = ret.Channel?.Guild;
 
 		//If this is a webhook, it shouldn't be in the user cache.
 		if (author.IsBot && int.Parse(author.Discriminator) == 0)
 		{
 			ret.Author = new DiscordUser(author) { Discord = this.Discord };
 		}
 		else
 		{
 			if (!this.Discord.UserCache.TryGetValue(author.Id, out var usr))
 			{
 				this.Discord.UserCache[author.Id] = usr = new DiscordUser(author) { Discord = this.Discord };
 			}
 
 			if (guild != null)
 			{
 				if (!guild.Members.TryGetValue(author.Id, out var mbr))
 					mbr = new DiscordMember(usr) { Discord = this.Discord, GuildId = guild.Id };
 				ret.Author = mbr;
 			}
 			else
 			{
 				ret.Author = usr;
 			}
 		}
 
 		ret.PopulateMentions();
 
 		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.ContainsKey(guildId) ? this.Discord.Guilds[guildId] : null;
 
 		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));
 	}
 
 	/// <summary>
 	/// Gets all auto mod rules for a guild.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <returns>A collection of all auto mod rules in the guild.</returns>
 	internal async Task<ReadOnlyCollection<AutomodRule>> GetAutomodRulesAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id/auto-moderation/rules";
 		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<List<AutomodRule>>(res.Response);
 		return ret.AsReadOnly();
 	}
 
 	/// <summary>
 	/// Gets a specific auto mod rule in the guild.
 	/// </summary>
 	/// <param name="guildId">The guild id for the rule.</param>
 	/// <param name="ruleId">The rule id.</param>
 	/// <returns>The rule if one is found.</returns>
 	internal async Task<AutomodRule> GetAutomodRuleAsync(ulong guildId, ulong ruleId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id/auto-moderation/rules/:rule_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id = guildId, rule_id = ruleId }, 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<AutomodRule>(res.Response);
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates an auto mod rule.
 	/// </summary>
 	/// <param name="guildId">The guild id of the rule.</param>
 	/// <param name="name">The name of the rule.</param>
 	/// <param name="eventType">The event type of the rule.</param>
 	/// <param name="triggerType">The trigger type.</param>
 	/// <param name="actions">The actions of the rule.</param>
 	/// <param name="triggerMetadata">The metadata of the rule.</param>
 	/// <param name="enabled">Whether this rule is enabled.</param>
 	/// <param name="exemptRoles">The exempt roles of the rule.</param>
 	/// <param name="exemptChannels">The exempt channels of the rule.</param>
 	/// <param name="reason">The reason for this addition.</param>
 	/// <returns>The new auto mod rule.</returns>
 	internal async Task<AutomodRule> CreateAutomodRuleAsync(ulong guildId, string name, AutomodEventType eventType, AutomodTriggerType triggerType, IEnumerable<AutomodAction> actions,
 		AutomodTriggerMetadata triggerMetadata = null, bool enabled = false, IEnumerable<ulong> exemptRoles = null, IEnumerable<ulong> exemptChannels = null, string reason = null)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id/auto-moderation/rules";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id = guildId }, out var path);
 
 		RestAutomodRuleModifyPayload pld = new()
 		{
 			Name = name,
 			EventType = eventType,
 			TriggerType = triggerType,
 			Actions = actions.ToArray(),
 			Enabled = enabled,
 			TriggerMetadata = triggerMetadata ?? null
 		};
 
 		if (exemptChannels != null)
 			pld.ExemptChannels = exemptChannels.ToArray();
 		if (exemptRoles != null)
 			pld.ExemptRoles = exemptRoles.ToArray();
 
 		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, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<AutomodRule>(res.Response);
 
 		if (this.Discord is DiscordClient dc)
 		{
 			await dc.OnAutomodRuleCreated(ret).ConfigureAwait(false);
 		}
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies an auto mod role
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="ruleId">The rule id.</param>
 	/// <param name="name">The new name of the rule.</param>
 	/// <param name="eventType">The new event type of the rule.</param>
 	/// <param name="metadata">The new metadata of the rule.</param>
 	/// <param name="actions">The new actions of the rule.</param>
 	/// <param name="enabled">Whether this rule is enabled.</param>
 	/// <param name="exemptRoles">The new exempt roles of the rule.</param>
 	/// <param name="exemptChannels">The new exempt channels of the rule.</param>
 	/// <param name="reason">The reason for this modification.</param>
 	/// <returns>The updated automod rule</returns>
 	internal async Task<AutomodRule> ModifyAutomodRuleAsync(ulong guildId, ulong ruleId, Optional<string> name, Optional<AutomodEventType> eventType, Optional<AutomodTriggerMetadata> metadata, Optional<List<AutomodAction>> actions,
 		Optional<bool> enabled, Optional<List<ulong>> exemptRoles, Optional<List<ulong>> exemptChannels, string reason = null)
 	{
 		var pld = new RestAutomodRuleModifyPayload
 		{
 			Name = name,
 			EventType = eventType,
 			TriggerMetadata = metadata,
 			Enabled = enabled
 		};
 
 		if (actions.HasValue)
 			pld.Actions = actions.Value?.ToArray();
 		if (exemptChannels.HasValue)
 			pld.ExemptChannels = exemptChannels.Value?.ToArray();
 		if (exemptRoles.HasValue)
 			pld.ExemptRoles = exemptRoles.Value?.ToArray();
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id/auto-moderation/rules/:rule_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId, rule_id = ruleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<AutomodRule>(res.Response);
 
 		if (this.Discord is DiscordClient dc)
 		{
 			await dc.OnAutomodRuleUpdated(ret).ConfigureAwait(false);
 		}
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes an auto mod rule.
 	/// </summary>
 	/// <param name="guildId">The guild id of the rule.</param>
 	/// <param name="ruleId">The rule id.</param>
 	/// <param name="reason">The reason for this deletion.</param>
 	/// <returns>The deleted auto mod rule.</returns>
 	internal async Task<AutomodRule> DeleteAutomodRuleAsync(ulong guildId, ulong ruleId, string reason = null)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id/auto-moderation/rules/:rule_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id = guildId, rule_id = ruleId }, 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.DELETE, route, headers).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<AutomodRule>(res.Response);
 
 		if (this.Discord is DiscordClient dc)
 		{
 			await dc.OnAutomodRuleDeleted(ret).ConfigureAwait(false);
 		}
 
 		return ret;
 	}
 
 
 	#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 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, Optional<ChannelFlags?> flags, 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,
 			Flags = flags
 		};
 
 		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.Initialize(this.Discord);
 
 		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, Optional<ForumPostSortOrder> defaultSortOrder,
 		ThreadAutoArchiveDuration? defaultAutoArchiveDuration, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, Optional<ChannelFlags?> flags, 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,
 			DefaultSortOrder = defaultSortOrder,
 			Flags = flags,
 			Type = ChannelType.Forum
 		};
 
 		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.Initialize(this.Discord);
 
 		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="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<ChannelFlags?> flags, 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,
 			Flags = flags,
 			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<DiscordChannel> ModifyForumChannelAsync(ulong channelId, string name, int? position,
 		Optional<string> topic, Optional<string> template, bool? nsfw,
 		Optional<ulong?> parent, Optional<List<ForumPostTag>?> availableTags, Optional<ForumReactionEmoji> defaultReactionEmoji,
 		Optional<int?> perUserRateLimit, Optional<int?> postCreateUserRateLimit, Optional<ForumPostSortOrder?> defaultSortOrder,
 		Optional<ThreadAutoArchiveDuration?> defaultAutoArchiveDuration, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, Optional<ChannelFlags?> flags, 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,
 			DefaultSortOrder = defaultSortOrder,
 			Flags = flags,
 			AvailableTags = availableTags
 		};
 
 		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);
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 		ret.Initialize(this.Discord);
 
 		return ret;
 	}
 
 	/// <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.Initialize(this.Discord);
 
 		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>
 	/// <param name="components">The components.</param>
 	internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, string content, IEnumerable<DiscordEmbed> embeds, DiscordSticker sticker, ulong? replyMessageId, bool mentionReply, bool failOnInvalidReply, ReadOnlyCollection<DiscordActionRowComponent>? components = null)
 	{
 		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 && components == null)
 				throw new ArgumentException("You must specify message content, a sticker, components 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,
 			Components = components
 		};
 
 		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)
 			ret.Initialize(this.Discord);
 
 		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 = StagePrivacyLevel.GuildOnly, string reason = null)
 	{
 		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="targetApplicationId">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, ulong? targetApplicationId, ulong? targetUser, bool temporary, bool unique, string reason)
 	{
 		var pld = new RestChannelInviteCreatePayload
 		{
 			MaxAge = maxAge,
 			MaxUses = maxUses,
 			TargetType = targetType,
 			TargetApplicationId = targetApplicationId,
 			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 };
 		if (this.Discord.Configuration.Intents.HasIntent(DiscordIntents.GuildPresences) && duser.Presence == null && this.Discord is DiscordClient dc)
 			dc.PresencesInternal[duser.Id] = new DiscordPresence
 			{
 				Discord = dc,
 				RawActivity = new TransportActivity(),
 				Activity = new DiscordActivity(),
 				Status = UserStatus.Offline,
 				InternalUser = new UserWithIdOnly { Id = duser.Id }
 			};
 
 		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;
 		});
 
 		if (this.Discord.Configuration.Intents.HasIntent(DiscordIntents.GuildPresences) && usr.Presence == null && this.Discord is DiscordClient dc)
 			dc.PresencesInternal[usr.Id] = new DiscordPresence
 			{
 				Discord = dc,
 				RawActivity = new TransportActivity(),
 				Activity = new DiscordActivity(),
 				Status = UserStatus.Offline
 			};
 
 		return new DiscordMember(tm)
 		{
 			Discord = this.Discord,
 			GuildId = guildId
 		};
 	}
 
 	/// <summary>
 	/// Removes the guild member async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task RemoveGuildMemberAsync(ulong guildId, ulong userId, string reason)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (reason != null)
 			urlParams["reason"] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(urlParams), this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Modifies the current user async.
 	/// </summary>
 	/// <param name="username">The username.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 
 	internal async Task<TransportUser> ModifyCurrentUserAsync(string username, Optional<string> base64Avatar)
 	{
 		var pld = new RestUserUpdateCurrentPayload
 		{
 			Username = username,
 			AvatarBase64 = base64Avatar.ValueOrDefault(),
 			AvatarSet = base64Avatar.HasValue
 		};
 
 		var route = $"{Endpoints.USERS}{Endpoints.ME}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 
 		return userRaw;
 	}
 
 	/// <summary>
 	/// Gets the current user guilds async.
 	/// </summary>
 	/// <param name="limit">The limit.</param>
 	/// <param name="before">The before.</param>
 	/// <param name="after">The after.</param>
 
 	internal async Task<IReadOnlyList<DiscordGuild>> GetCurrentUserGuildsAsync(int limit = 100, ulong? before = null, ulong? after = null)
 	{
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}";
 
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration)
 			.AddParameter($"limit", limit.ToString(CultureInfo.InvariantCulture));
 
 		if (before != null)
 			url.AddParameter("before", before.Value.ToString(CultureInfo.InvariantCulture));
 		if (after != null)
 			url.AddParameter("after", after.Value.ToString(CultureInfo.InvariantCulture));
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url.Build(), RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		if (this.Discord is DiscordClient)
 		{
 			var guildsRaw = JsonConvert.DeserializeObject<IEnumerable<RestUserGuild>>(res.Response);
 			var glds = guildsRaw.Select(xug => (this.Discord as DiscordClient)?.GuildsInternal[xug.Id]);
 			return new ReadOnlyCollection<DiscordGuild>(new List<DiscordGuild>(glds));
 		}
 		else
 		{
 			return new ReadOnlyCollection<DiscordGuild>(JsonConvert.DeserializeObject<List<DiscordGuild>>(res.Response));
 		}
 	}
 
 	/// <summary>
 	/// Modifies the guild member async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="roleIds">The role_ids.</param>
 	/// <param name="mute">The mute.</param>
 	/// <param name="deaf">The deaf.</param>
 	/// <param name="voiceChannelId">The voice_channel_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyGuildMemberAsync(ulong guildId, ulong userId, Optional<string> nick,
 		Optional<IEnumerable<ulong>> roleIds, Optional<bool> mute, Optional<bool> deaf,
 		Optional<ulong?> voiceChannelId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var pld = new RestGuildMemberModifyPayload
 		{
 			Nickname = nick,
 			RoleIds = roleIds,
 			Deafen = deaf,
 			Mute = mute,
 			VoiceChannelId = voiceChannelId
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Modifies the time out of a guild member.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="until">Datetime offset.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyTimeoutAsync(ulong guildId, ulong userId, DateTimeOffset? until, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var pld = new RestGuildMemberTimeoutModifyPayload
 		{
 			CommunicationDisabledUntil = until
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Modifies the current member nickname async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyCurrentMemberNicknameAsync(ulong guildId, string nick, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var pld = new RestGuildMemberModifyPayload
 		{
 			Nickname = nick
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.ME}{Endpoints.NICK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 	}
 	#endregion
 
 	#region Roles
 	/// <summary>
 	/// Gets the guild roles async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordRole>> GetGuildRolesAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var rolesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordRole>>(res.Response).Select(xr => { xr.Discord = this.Discord; xr.GuildId = guildId; return xr; });
 
 		return new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(rolesRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild async.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="withCounts">If true, with_counts.</param>
 
 	internal async Task<DiscordGuild> GetGuildAsync(ulong guildId, bool? withCounts)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (withCounts.HasValue)
 			urlParams["with_counts"] = withCounts?.ToString();
 
 		var route = $"{Endpoints.GUILDS}/:guild_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, urlParams).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawMembers = (JArray)json["members"];
 		var guildRest = json.ToDiscordObject<DiscordGuild>();
 		foreach (var r in guildRest.RolesInternal.Values)
 			r.GuildId = guildRest.Id;
 
 		if (this.Discord is DiscordClient dc)
 		{
 			await dc.OnGuildUpdateEventAsync(guildRest, rawMembers).ConfigureAwait(false);
 			return dc.GuildsInternal[guildRest.Id];
 		}
 		else
 		{
 			guildRest.Discord = this.Discord;
 			return guildRest;
 		}
 	}
 
 	/// <summary>
 	/// Modifies the guild role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="roleId">The role_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="permissions">The permissions.</param>
 	/// <param name="color">The color.</param>
 	/// <param name="hoist">If true, hoist.</param>
 	/// <param name="mentionable">If true, mentionable.</param>
 	/// <param name="iconb64">The icon.</param>
 	/// <param name="emoji">The unicode emoji icon.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordRole> ModifyGuildRoleAsync(ulong guildId, ulong roleId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, Optional<string> iconb64, Optional<string> emoji, string reason)
 	{
 		var pld = new RestGuildRolePayload
 		{
 			Name = name,
 			Permissions = permissions & PermissionMethods.FullPerms,
 			Color = color,
 			Hoist = hoist,
 			Mentionable = mentionable,
 		};
 
 		if (emoji.HasValue && !iconb64.HasValue)
 			pld.UnicodeEmoji = emoji;
 
 		if (emoji.HasValue && iconb64.HasValue)
 		{
 			pld.IconBase64 = null;
 			pld.UnicodeEmoji = emoji;
 		}
 
 		if (iconb64.HasValue)
 			pld.IconBase64 = iconb64;
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 		ret.Discord = this.Discord;
 		ret.GuildId = guildId;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="roleId">The role_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteRoleAsync(ulong guildId, ulong roleId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Creates the guild role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="permissions">The permissions.</param>
 	/// <param name="color">The color.</param>
 	/// <param name="hoist">If true, hoist.</param>
 	/// <param name="mentionable">If true, mentionable.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordRole> CreateGuildRoleAsync(ulong guildId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, string reason)
 	{
 		var pld = new RestGuildRolePayload
 		{
 			Name = name,
 			Permissions = permissions & PermissionMethods.FullPerms,
 			Color = color,
 			Hoist = hoist,
 			Mentionable = mentionable
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 		ret.Discord = this.Discord;
 		ret.GuildId = guildId;
 
 		return ret;
 	}
 	#endregion
 
 	#region Prune
 	/// <summary>
 	/// Gets the guild prune count async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="days">The days.</param>
 	/// <param name="includeRoles">The include_roles.</param>
 
 	internal async Task<int> GetGuildPruneCountAsync(ulong guildId, int days, IEnumerable<ulong> includeRoles)
 	{
 		if (days < 0 || days > 30)
 			throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 		var urlParams = new Dictionary<string, string>
 		{
 			["days"] = days.ToString(CultureInfo.InvariantCulture)
 		};
 
 		var sb = includeRoles?.Aggregate(new StringBuilder(),
 					 (sb, id) => sb.Append($"&include_roles={id}"))
 				 ?? new StringBuilder();
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 		var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlParams)}{sb}", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 		return pruned.Pruned.Value;
 	}
 
 	/// <summary>
 	/// Begins the guild prune async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="days">The days.</param>
 	/// <param name="computePruneCount">If true, compute_prune_count.</param>
 	/// <param name="includeRoles">The include_roles.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<int?> BeginGuildPruneAsync(ulong guildId, int days, bool computePruneCount, IEnumerable<ulong> includeRoles, string reason)
 	{
 		if (days < 0 || days > 30)
 			throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 		var urlParams = new Dictionary<string, string>
 		{
 			["days"] = days.ToString(CultureInfo.InvariantCulture),
 			["compute_prune_count"] = computePruneCount.ToString()
 		};
 
 		var sb = includeRoles?.Aggregate(new StringBuilder(),
 					 (sb, id) => sb.Append($"&include_roles={id}"))
 				 ?? new StringBuilder();
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlParams)}{sb}", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers).ConfigureAwait(false);
 
 		var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 		return pruned.Pruned;
 	}
 	#endregion
 
 	#region GuildVarious
 	/// <summary>
 	/// Gets the template async.
 	/// </summary>
 	/// <param name="code">The code.</param>
 
 	internal async Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 	{
 		var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { code }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var templatesRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 		return templatesRaw;
 	}
 
 	/// <summary>
 	/// Gets the guild integrations async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordIntegration>> GetGuildIntegrationsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var integrationsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordIntegration>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 		return new ReadOnlyCollection<DiscordIntegration>(new List<DiscordIntegration>(integrationsRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild preview async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PREVIEW}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordGuildPreview>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="id">The id.</param>
 
 	internal async Task<DiscordIntegration> CreateGuildIntegrationAsync(ulong guildId, string type, ulong id)
 	{
 		var pld = new RestGuildIntegrationAttachPayload
 		{
 			Type = type,
 			Id = id
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="integrationId">The integration_id.</param>
 	/// <param name="expireBehaviour">The expire_behaviour.</param>
 	/// <param name="expireGracePeriod">The expire_grace_period.</param>
 	/// <param name="enableEmoticons">If true, enable_emoticons.</param>
 
 	internal async Task<DiscordIntegration> ModifyGuildIntegrationAsync(ulong guildId, ulong integrationId, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 	{
 		var pld = new RestGuildIntegrationModifyPayload
 		{
 			ExpireBehavior = expireBehaviour,
 			ExpireGracePeriod = expireGracePeriod,
 			EnableEmoticons = enableEmoticons
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="integration">The integration.</param>
 
 	internal Task DeleteGuildIntegrationAsync(ulong guildId, DiscordIntegration integration)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, integration_id = integration.Id }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, payload: DiscordJson.SerializeObject(integration));
 	}
 
 	/// <summary>
 	/// Syncs the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="integrationId">The integration_id.</param>
 
 	internal Task SyncGuildIntegrationAsync(ulong guildId, ulong integrationId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id{Endpoints.SYNC}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 	}
 
 	/// <summary>
 	/// Gets the guild voice regions async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordVoiceRegion>> GetGuildVoiceRegionsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.REGIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var regionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 		return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regionsRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild invites async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordInvite>> GetGuildInvitesAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INVITES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 		return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 	}
 	#endregion
 
 	#region Invite
 	/// <summary>
 	/// Gets the invite async.
 	/// </summary>
 	/// <param name="inviteCode">The invite_code.</param>
 	/// <param name="withCounts">If true, with_counts.</param>
 	/// <param name="withExpiration">If true, with_expiration.</param>
 	/// <param name="guildScheduledEventId">The scheduled event id to get.</param>
 
 	internal async Task<DiscordInvite> GetInviteAsync(string inviteCode, bool? withCounts, bool? withExpiration, ulong? guildScheduledEventId)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (withCounts.HasValue)
 			urlParams["with_counts"] = withCounts?.ToString();
 		if (withExpiration.HasValue)
 			urlParams["with_expiration"] = withExpiration?.ToString();
 		if (guildScheduledEventId.HasValue)
 			urlParams["guild_scheduled_event_id"] = guildScheduledEventId?.ToString();
 
 		var route = $"{Endpoints.INVITES}/:invite_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {invite_code = inviteCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the invite async.
 	/// </summary>
 	/// <param name="inviteCode">The invite_code.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordInvite> DeleteInviteAsync(string inviteCode, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.INVITES}/:invite_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {invite_code = inviteCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/*
          * Disabled due to API restrictions
          *
          * internal async Task<DiscordInvite> InternalAcceptInvite(string invite_code)
          * {
          *     this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "REST API", "Invite accept endpoint was used; this account is now likely unverified", DateTime.Now);
          *
          *     var url = new Uri($"{Utils.GetApiBaseUri(this.Configuration), Endpoints.INVITES}/{invite_code));
          *     var bucket = this.Rest.GetBucket(0, MajorParameterType.Unbucketed, url, HttpRequestMethod.POST);
          *     var res = await this.DoRequestAsync(this.Discord, bucket, url, HttpRequestMethod.POST).ConfigureAwait(false);
          *
          *     var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
          *     ret.Discord = this.Discord;
          *
          *     return ret;
          * }
          */
 	#endregion
 
 	#region Connections
 	/// <summary>
 	/// Gets the users connections async.
 	/// </summary>
 
 	internal async Task<IReadOnlyList<DiscordConnection>> GetUserConnectionsAsync()
 	{
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CONNECTIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var connectionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordConnection>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 		return new ReadOnlyCollection<DiscordConnection>(new List<DiscordConnection>(connectionsRaw));
 	}
 	#endregion
 
 	#region Voice
 	/// <summary>
 	/// Lists the voice regions async.
 	/// </summary>
 
 	internal async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 	{
 		var route = $"{Endpoints.VOICE}{Endpoints.REGIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var regions = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 		return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regions));
 	}
 	#endregion
 
 	#region Webhooks
 	/// <summary>
 	/// Creates the webhook async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWebhook> CreateWebhookAsync(ulong channelId, string name, Optional<string> base64Avatar, string reason)
 	{
 		var pld = new RestWebhookPayload
 		{
 			Name = name,
 			AvatarBase64 = base64Avatar.ValueOrDefault(),
 			AvatarSet = base64Avatar.HasValue
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the channel webhooks async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordWebhook>> GetChannelWebhooksAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 		return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild webhooks async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordWebhook>> GetGuildWebhooksAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WEBHOOKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 		return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 	}
 
 	/// <summary>
 	/// Gets the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 
 	internal async Task<DiscordWebhook> GetWebhookAsync(ulong webhookId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the webhook with token async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 
 	internal async Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong webhookId, string webhookToken)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Token = webhookToken;
 		ret.Id = webhookId;
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, ulong channelId, string name, Optional<string> base64Avatar, string reason)
 	{
 		var pld = new RestWebhookPayload
 		{
 			Name = name,
 			AvatarBase64 = base64Avatar.ValueOrDefault(),
 			AvatarSet = base64Avatar.HasValue,
 			ChannelId = channelId
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, string name, string base64Avatar, string webhookToken, string reason)
 	{
 		var pld = new RestWebhookPayload
 		{
 			Name = name,
 			AvatarBase64 = base64Avatar
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteWebhookAsync(ulong webhookId, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Deletes the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteWebhookAsync(ulong webhookId, string webhookToken, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Executes the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="builder">The builder.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> ExecuteWebhookAsync(ulong webhookId, string webhookToken, DiscordWebhookBuilder builder, string threadId)
 	{
 		builder.Validate();
 
 		if (builder.Embeds != null)
 			foreach (var embed in builder.Embeds)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var values = new Dictionary<string, string>();
 		var pld = new RestWebhookExecutePayload
 		{
 			Content = builder.Content,
 			Username = builder.Username.ValueOrDefault(),
 			AvatarUrl = builder.AvatarUrl.ValueOrDefault(),
 			IsTts = builder.IsTts,
 			Embeds = builder.Embeds,
 			Components = builder.Components,
 			ThreadName = builder.ThreadName
 		};
 
 		if (builder.Mentions != null)
 			pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 		if (builder.Files?.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new();
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName,
 					FileSize = null
 				};
 				attachments.Add(att);
 				fileId++;
 			}
 			pld.Attachments = attachments;
 		}
 
 		if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count > 0 || builder.Files?.Count > 0 || builder.IsTts == true || builder.Mentions != null)
 			values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 
 		var url = qub.Build();
 
 		var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 		foreach (var att in ret.Attachments)
 			att.Discord = this.Discord;
 
 		foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 		{
 			file.Stream.Position = file.ResetPositionTo.Value;
 		}
 
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Executes the webhook slack async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="jsonPayload">The json_payload.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> ExecuteWebhookSlackAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.SLACK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 		var url = qub.Build();
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Executes the webhook github async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="jsonPayload">The json_payload.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> ExecuteWebhookGithubAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.GITHUB}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 		var url = qub.Build();
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Edits the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="builder">The builder.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, DiscordWebhookBuilder builder, string threadId)
 	{
 		builder.Validate(true);
 
 		var pld = new RestWebhookMessageEditPayload
 		{
 			Content = builder.Content,
 			Embeds = builder.Embeds,
 			Mentions = builder.Mentions,
 			Components = builder.Components,
 		};
 
 		if (builder.Files?.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new();
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName,
 					FileSize = null
 				};
 				attachments.Add(att);
 				fileId++;
 			}
-			if (builder.Attachments != null && builder.Attachments?.Count() > 0)
+			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 : 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 : 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 : 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 : 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 : 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="appliedTags">The tags to add on creation.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordThreadChannel> CreateThreadAsync(ulong channelId, ulong? messageId, string name,
 		ThreadAutoArchiveDuration? autoArchiveDuration, ChannelType? type, int? rateLimitPerUser, IEnumerable<ForumPostTag>? appliedTags = null, DiscordMessageBuilder builder = null, bool isForum = false, string reason = null)
 	{
 		var pld = new RestThreadChannelCreatePayload
 		{
 			Name = name,
 			AutoArchiveDuration = autoArchiveDuration,
 			PerUserRateLimit = rateLimitPerUser
 		};
 
 		if (isForum)
 		{
 
 			pld.Message = new RestChannelMessageCreatePayload
 			{
 				Content = builder.Content,
 				Attachments = builder.Attachments,
 				Components = builder.Components,
 				HasContent = true,
 				Embeds = builder.Embeds,
 				//Flags = builder.Flags,
 				//Mentions = builder.Mentions,
 				StickersIds = builder.Sticker != null ? new List<ulong>(1)
 				{
 					builder.Sticker.Id
 				} : null
 			};
 			if (appliedTags != null && appliedTags.Any())
 			{
 				List<ulong> tags = new();
 
 				foreach (var b in appliedTags)
 					tags.Add(b.Id.Value);
 
 				pld.AppliedTags = tags;
 				pld.Type = null;
 			}
 		}
 		else
 		{
 			pld.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="parentType">The parent channels type as failback to ignore forum fields.</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="appliedTags">The tags to add on creation.</param>
 	/// <param name="reason">The reason for the modification.</param>
 	internal Task ModifyThreadAsync(ulong threadId, ChannelType parentType, string name, Optional<bool?> locked, Optional<bool?> archived, Optional<int?> perUserRateLimit, Optional<ThreadAutoArchiveDuration?> autoArchiveDuration, Optional<bool?> invitable, Optional<IEnumerable<ForumPostTag>> appliedTags, string reason)
 	{
 		var pld = new RestThreadChannelModifyPayload
 		{
 			Name = name,
 			Archived = archived,
 			AutoArchiveDuration = autoArchiveDuration,
 			Locked = locked,
 			PerUserRateLimit = perUserRateLimit,
 			Invitable = invitable
 		};
 		// TODO: Pinned threads in forum
 		if (parentType == ChannelType.Forum)
 		{
 			if (appliedTags.HasValue && appliedTags.Value != null)
 			{
 				List<ulong> tags = new(appliedTags.Value.Count());
 
 				foreach (var b in appliedTags.Value)
 					tags.Add(b.Id.Value);
 
 				pld.AppliedTags = tags;
 			}
 		}
 
 		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));
 	}
 
 	#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<List<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<List<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)))
 			throw new NotSupportedException("Can't send any other type then Input Text as Modal Component.");
 
 		var pld = new RestInteractionModalResponsePayload
 		{
 			Type = type,
 			Data = new DiscordInteractionApplicationCommandModalCallbackData
 			{
 				Title = builder.Title,
 				CustomId = builder.CustomId,
 				ModalComponents = builder.ModalComponents
 			}
 		};
 
 		var values = new Dictionary<string, string>();
 
 		var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Gets the original interaction response.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	internal Task<DiscordMessage> GetOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 		this.GetWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 	/// <summary>
 	/// Edits the original interaction response.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="builder">The builder.</param>
 	internal Task<DiscordMessage> EditOriginalInteractionResponseAsync(ulong applicationId, string interactionToken, DiscordWebhookBuilder builder) =>
 		this.EditWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, builder, null);
 
 	/// <summary>
 	/// Deletes the original interaction response.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	internal Task DeleteOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 		this.DeleteWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 	/// <summary>
 	/// Creates the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="builder">The builder.</param>
 	internal async Task<DiscordMessage> CreateFollowupMessageAsync(ulong applicationId, string interactionToken, DiscordFollowupMessageBuilder builder)
 	{
 		builder.Validate();
 
 		if (builder.Embeds != null)
 			foreach (var embed in builder.Embeds)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var values = new Dictionary<string, string>();
 		var pld = new RestFollowupMessageCreatePayload
 		{
 			Content = builder.Content,
 			IsTts = builder.IsTts,
 			Embeds = builder.Embeds,
 			Flags = builder.Flags,
 			Components = builder.Components
 		};
 
 
 		if (builder.Files != null && builder.Files.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new();
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName,
 					FileSize = null
 				};
 				attachments.Add(att);
 				fileId++;
 			}
 			pld.Attachments = attachments;
 		}
 
 		if (builder.Mentions != null)
 			pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 		if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 			values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 		var route = $"{Endpoints.WEBHOOKS}/:application_id/:interaction_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, interaction_token = interactionToken }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 		var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 		foreach (var att in ret.AttachmentsInternal)
 		{
 			att.Discord = this.Discord;
 		}
 
 		foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 		{
 			file.Stream.Position = file.ResetPositionTo.Value;
 		}
 
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="messageId">The message id.</param>
 	internal Task<DiscordMessage> GetFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 		this.GetWebhookMessageAsync(applicationId, interactionToken, messageId);
 
 	/// <summary>
 	/// Edits the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="builder">The builder.</param>
 	internal Task<DiscordMessage> EditFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId, DiscordWebhookBuilder builder) =>
 		this.EditWebhookMessageAsync(applicationId, interactionToken, messageId.ToString(), builder, null);
 
 	/// <summary>
 	/// Deletes the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="messageId">The message id.</param>
 	internal Task DeleteFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 		this.DeleteWebhookMessageAsync(applicationId, interactionToken, messageId);
 	#endregion
 
 	#region Misc
 	/// <summary>
 	/// Gets the current application info.
 	/// </summary>
 	internal Task<TransportApplication> GetCurrentApplicationInfoAsync()
 		=> this.GetApplicationInfoAsync("@me");
 
 	/// <summary>
 	/// Gets the application rpc info.
 	/// </summary>
 	/// <param name="applicationId">The application_id.</param>
 	internal Task<DiscordRpcApplication> GetApplicationInfoAsync(ulong applicationId)
 		=> this.GetApplicationRpcInfoAsync(applicationId.ToString(CultureInfo.InvariantCulture));
 
 	/// <summary>
 	/// Gets the application info.
 	/// </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 info.
 	/// </summary>
 	/// <param name="applicationId">The application_id.</param>
 	private async Task<DiscordRpcApplication> GetApplicationRpcInfoAsync(string applicationId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.RPC}";
 		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<DiscordRpcApplication>(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/RestClient.cs b/DisCatSharp/Net/Rest/RestClient.cs
index 6225c72ae..5f99e600b 100644
--- a/DisCatSharp/Net/Rest/RestClient.cs
+++ b/DisCatSharp/Net/Rest/RestClient.cs
@@ -1,870 +1,870 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Exceptions;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Net;
 
 /// <summary>
 /// Represents a client used to make REST requests.
 /// </summary>
 internal sealed class RestClient : IDisposable
 {
 	/// <summary>
 	/// Gets the route argument regex.
 	/// </summary>
 	private static Regex s_routeArgumentRegex { get; } = new(@":([a-z_]+)");
 
 	/// <summary>
 	/// Gets the http client.
 	/// </summary>
 	internal HttpClient HttpClient { get; }
 
 	/// <summary>
 	/// Gets the discord client.
 	/// </summary>
 	private readonly BaseDiscordClient _discord;
 
 	/// <summary>
 	/// Gets a value indicating whether debug is enabled.
 	/// </summary>
 	internal bool Debug { get; set; }
 
 	/// <summary>
 	/// Gets the logger.
 	/// </summary>
 	private readonly ILogger _logger;
 
 	/// <summary>
 	/// Gets the routes to hashes.
 	/// </summary>
 	private readonly ConcurrentDictionary<string, string> _routesToHashes;
 
 	/// <summary>
 	/// Gets the hashes to buckets.
 	/// </summary>
 	private readonly ConcurrentDictionary<string, RateLimitBucket> _hashesToBuckets;
 
 	/// <summary>
 	/// Gets the request queue.
 	/// </summary>
 	private readonly ConcurrentDictionary<string, int> _requestQueue;
 
 	/// <summary>
 	/// Gets the global rate limit event.
 	/// </summary>
 	private readonly AsyncManualResetEvent _globalRateLimitEvent;
 
 	/// <summary>
 	/// Gets a value indicating whether use reset after.
 	/// </summary>
 	private readonly bool _useResetAfter;
 
 	private CancellationTokenSource _bucketCleanerTokenSource;
 	private readonly TimeSpan _bucketCleanupDelay = TimeSpan.FromSeconds(60);
 	private volatile bool _cleanerRunning;
 	private Task _cleanerTask;
 	private volatile bool _disposed;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="RestClient"/> class.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	internal RestClient(BaseDiscordClient client)
 		: this(client.Configuration.Proxy, client.Configuration.HttpTimeout, client.Configuration.UseRelativeRatelimit, client.Logger)
 	{
 		this._discord = client;
 		this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", Utilities.GetFormattedToken(client));
 		if (client.Configuration.Override != null)
 		{
 			this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", client.Configuration.Override);
 		}
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="RestClient"/> class.
 	/// This is for meta-clients, such as the webhook client.
 	/// </summary>
 	/// <param name="proxy">The proxy.</param>
 	/// <param name="timeout">The timeout.</param>
 	/// <param name="useRelativeRatelimit">Whether to use relative ratelimit.</param>
 	/// <param name="logger">The logger.</param>
 	internal RestClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRatelimit,
 		ILogger logger)
 	{
 		this._logger = logger;
 
 		var httphandler = new HttpClientHandler
 		{
 			UseCookies = false,
 			AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
 			UseProxy = proxy != null,
 			Proxy = proxy
 		};
 
 		this.HttpClient = new HttpClient(httphandler)
 		{
 			BaseAddress = new Uri(Utilities.GetApiBaseUri(this._discord?.Configuration)),
 			Timeout = timeout
 		};
 
 		this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 		if (this._discord != null && this._discord.Configuration != null && this._discord.Configuration.Override != null)
 			this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this._discord.Configuration.Override);
 
 		this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("X-Discord-Locale", this._discord?.Configuration?.Locale ?? "en-US");
 
 		this._routesToHashes = new ConcurrentDictionary<string, string>();
 		this._hashesToBuckets = new ConcurrentDictionary<string, RateLimitBucket>();
 		this._requestQueue = new ConcurrentDictionary<string, int>();
 
 		this._globalRateLimitEvent = new AsyncManualResetEvent(true);
 		this._useResetAfter = useRelativeRatelimit;
 	}
 
 	/// <summary>
 	/// Gets a ratelimit bucket.
 	/// </summary>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="routeParams">The route parameters.</param>
 	/// <param name="url">The url.</param>
 	/// <returns>A ratelimit bucket.</returns>
 	public RateLimitBucket GetBucket(RestRequestMethod method, string route, object routeParams, out string url)
 	{
 		var rparamsProps = routeParams.GetType()
 			.GetTypeInfo()
 			.DeclaredProperties;
 		var rparams = new Dictionary<string, string>();
 		foreach (var xp in rparamsProps)
 		{
 			var val = xp.GetValue(routeParams);
 			rparams[xp.Name] = val is string xs
 				? xs
 				: val is DateTime dt
 				? dt.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture)
 				: val is DateTimeOffset dto
 				? dto.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture)
 				: val is IFormattable xf ? xf.ToString(null, CultureInfo.InvariantCulture) : val.ToString();
 		}
 
-		var guildId = rparams.ContainsKey("guild_id") ? rparams["guild_id"] : "";
-		var channelId = rparams.ContainsKey("channel_id") ? rparams["channel_id"] : "";
-		var webhookId = rparams.ContainsKey("webhook_id") ? rparams["webhook_id"] : "";
+		var guildId = rparams.TryGetValue("guild_id", out var value1) ? value1 : "";
+		var channelId = rparams.TryGetValue("channel_id", out var value2) ? value2 : "";
+		var webhookId = rparams.TryGetValue("webhook_id", out var value3) ? value3 : "";
 
 		// Create a generic route (minus major params) key
 		// ex: POST:/channels/channel_id/messages
 		var hashKey = RateLimitBucket.GenerateHashKey(method, route);
 
 		// We check if the hash is present, using our generic route (without major params)
 		// ex: in POST:/channels/channel_id/messages, out 80c17d2f203122d936070c88c8d10f33
 		// If it doesn't exist, we create an unlimited hash as our initial key in the form of the hash key + the unlimited constant
 		// and assign this to the route to hash cache
 		// ex: this.RoutesToHashes[POST:/channels/channel_id/messages] = POST:/channels/channel_id/messages:unlimited
 		var hash = this._routesToHashes.GetOrAdd(hashKey, RateLimitBucket.GenerateUnlimitedHash(method, route));
 
 		// Next we use the hash to generate the key to obtain the bucket.
 		// ex: 80c17d2f203122d936070c88c8d10f33:guild_id:506128773926879242:webhook_id
 		// or if unlimited: POST:/channels/channel_id/messages:unlimited:guild_id:506128773926879242:webhook_id
 		var bucketId = RateLimitBucket.GenerateBucketId(hash, guildId, channelId, webhookId);
 
 		// If it's not in cache, create a new bucket and index it by its bucket id.
 		var bucket = this._hashesToBuckets.GetOrAdd(bucketId, new RateLimitBucket(hash, guildId, channelId, webhookId));
 
 		bucket.LastAttemptAt = DateTimeOffset.UtcNow;
 
 		// Cache the routes for each bucket so it can be used for GC later.
 		if (!bucket.RouteHashes.Contains(bucketId))
 			bucket.RouteHashes.Add(bucketId);
 
 		// Add the current route to the request queue, which indexes the amount
 		// of requests occurring to the bucket id.
 		_ = this._requestQueue.TryGetValue(bucketId, out var count);
 
 		// Increment by one atomically due to concurrency
 		this._requestQueue[bucketId] = Interlocked.Increment(ref count);
 
 		// Start bucket cleaner if not already running.
 		if (!this._cleanerRunning)
 		{
 			this._cleanerRunning = true;
 			this._bucketCleanerTokenSource = new CancellationTokenSource();
 			this._cleanerTask = Task.Run(this.CleanupBucketsAsync, this._bucketCleanerTokenSource.Token);
 			this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task started.");
 		}
 
 		url = s_routeArgumentRegex.Replace(route, xm => rparams[xm.Groups[1].Value]);
 		return bucket;
 	}
 
 	/// <summary>
 	/// Executes the request.
 	/// </summary>
 	/// <param name="request">The request to be executed.</param>
 	public Task ExecuteRequestAsync(BaseRestRequest request)
 		=> request == null ? throw new ArgumentNullException(nameof(request)) : this.ExecuteRequestAsync(request, null, null);
 
 	/// <summary>
 	/// Executes the request.
 	/// This is to allow proper rescheduling of the first request from a bucket.
 	/// </summary>
 	/// <param name="request">The request to be executed.</param>
 	/// <param name="bucket">The bucket.</param>
 	/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 	private async Task ExecuteRequestAsync(BaseRestRequest request, RateLimitBucket bucket, TaskCompletionSource<bool> ratelimitTcs)
 	{
 		if (this._disposed)
 			return;
 
 		HttpResponseMessage res = default;
 
 		try
 		{
 			await this._globalRateLimitEvent.WaitAsync().ConfigureAwait(false);
 
 			bucket ??= request.RateLimitBucket;
 
 			ratelimitTcs ??= await this.WaitForInitialRateLimit(bucket).ConfigureAwait(false);
 
 			if (ratelimitTcs == null) // check rate limit only if we are not the probe request
 			{
 				var now = DateTimeOffset.UtcNow;
 
 				await bucket.TryResetLimitAsync(now).ConfigureAwait(false);
 
 				// Decrement the remaining number of requests as there can be other concurrent requests before this one finishes and has a chance to update the bucket
 				if (Interlocked.Decrement(ref bucket.RemainingInternal) < 0)
 				{
 					this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Request for {0} is blocked", bucket.ToString());
 					var delay = bucket.Reset - now;
 					var resetDate = bucket.Reset;
 
 					if (this._useResetAfter)
 					{
 						delay = bucket.ResetAfter.Value;
 						resetDate = bucket.ResetAfterOffset;
 					}
 
 					if (delay < new TimeSpan(-TimeSpan.TicksPerMinute))
 					{
 						this._logger.LogError(LoggerEvents.RatelimitDiag, "Failed to retrieve ratelimits - giving up and allowing next request for bucket");
 						bucket.RemainingInternal = 1;
 					}
 
 					if (delay < TimeSpan.Zero)
 						delay = TimeSpan.FromMilliseconds(100);
 
 					this._logger.LogWarning(LoggerEvents.RatelimitPreemptive, "Preemptive ratelimit triggered - waiting until {0:yyyy-MM-dd HH:mm:ss zzz} ({1:c}).", resetDate, delay);
 					Task.Delay(delay)
 						.ContinueWith(_ => this.ExecuteRequestAsync(request, null, null))
 						.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 
 					return;
 				}
 				this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Request for {0} is allowed", bucket.ToString());
 			}
 			else
 				this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Initial request for {0} is allowed", bucket.ToString());
 
 			var req = this.BuildRequest(request);
 
 			if (this.Debug)
 				this._logger.LogTrace(LoggerEvents.Misc, await req.Content.ReadAsStringAsync());
 
 			var response = new RestResponse();
 			try
 			{
 				if (this._disposed)
 					return;
 
 				res = await this.HttpClient.SendAsync(req, HttpCompletionOption.ResponseContentRead, CancellationToken.None).ConfigureAwait(false);
 
 				var bts = await res.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
 				var txt = Utilities.UTF8.GetString(bts, 0, bts.Length);
 
 				this._logger.LogTrace(LoggerEvents.RestRx, txt);
 
 				response.Headers = res.Headers.ToDictionary(xh => xh.Key, xh => string.Join("\n", xh.Value), StringComparer.OrdinalIgnoreCase);
 				response.Response = txt;
 				response.ResponseCode = (int)res.StatusCode;
 			}
 			catch (HttpRequestException httpex)
 			{
 				this._logger.LogError(LoggerEvents.RestError, httpex, "Request to {0} triggered an HttpException", request.Url);
 				request.SetFaulted(httpex);
 				this.FailInitialRateLimitTest(request, ratelimitTcs);
 				return;
 			}
 
 			this.UpdateBucket(request, response, ratelimitTcs);
 
 			Exception ex = null;
 			switch (response.ResponseCode)
 			{
 				case 400:
 				case 405:
 					ex = new BadRequestException(request, response);
 					break;
 
 				case 401:
 				case 403:
 					ex = new UnauthorizedException(request, response);
 					break;
 
 				case 404:
 					ex = new NotFoundException(request, response);
 					break;
 
 				case 413:
 					ex = new RequestSizeException(request, response);
 					break;
 
 				case 429:
 					ex = new RateLimitException(request, response);
 
 					// check the limit info and requeue
 					this.Handle429(response, out var wait, out var global);
 					if (wait != null)
 					{
 						if (global)
 						{
 							bucket.IsGlobal = true;
 							this._logger.LogError(LoggerEvents.RatelimitHit, "Global ratelimit hit, cooling down");
 							try
 							{
 								this._globalRateLimitEvent.Reset();
 								await wait.ConfigureAwait(false);
 							}
 							finally
 							{
 								// we don't want to wait here until all the blocked requests have been run, additionally Set can never throw an exception that could be suppressed here
 								_ = this._globalRateLimitEvent.SetAsync();
 							}
 							this.ExecuteRequestAsync(request, bucket, ratelimitTcs)
 								.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while retrying request");
 						}
 						else
 						{
 							if (this._discord is DiscordClient)
 							{
 								await (this._discord as DiscordClient)._rateLimitHit.InvokeAsync(this._discord as DiscordClient, new EventArgs.RateLimitExceptionEventArgs(this._discord.ServiceProvider)
 								{
 									Exception = ex as RateLimitException,
 									ApiEndpoint = request.Url.AbsoluteUri
 								});
 							}
 							this._logger.LogError(LoggerEvents.RatelimitHit, "Ratelimit hit, requeuing request to {0}", request.Url);
 							await wait.ConfigureAwait(false);
 							this.ExecuteRequestAsync(request, bucket, ratelimitTcs)
 								.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while retrying request");
 						}
 
 						return;
 					}
 					break;
 
 				case 500:
 				case 502:
 				case 503:
 				case 504:
 					ex = new ServerErrorException(request, response);
 					break;
 			}
 
 			if (ex != null)
 				request.SetFaulted(ex);
 			else
 				request.SetCompleted(response);
 		}
 		catch (Exception ex)
 		{
 			this._logger.LogError(LoggerEvents.RestError, ex, "Request to {0} triggered an exception", request.Url);
 
 			// if something went wrong and we couldn't get rate limits for the first request here, allow the next request to run
 			if (bucket != null && ratelimitTcs != null && bucket.LimitTesting != 0)
 				this.FailInitialRateLimitTest(request, ratelimitTcs);
 
 			if (!request.TrySetFaulted(ex))
 				throw;
 		}
 		finally
 		{
 			res?.Dispose();
 
 			// Get and decrement active requests in this bucket by 1.
 			_ = this._requestQueue.TryGetValue(bucket.BucketId, out var count);
 			this._requestQueue[bucket.BucketId] = Interlocked.Decrement(ref count);
 
 			// If it's 0 or less, we can remove the bucket from the active request queue,
 			// along with any of its past routes.
 			if (count <= 0)
 			{
 				foreach (var r in bucket.RouteHashes)
 				{
 					if (this._requestQueue.ContainsKey(r))
 					{
 						_ = this._requestQueue.TryRemove(r, out _);
 					}
 				}
 			}
 		}
 	}
 
 	/// <summary>
 	/// Fails the initial rate limit test.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 	/// <param name="resetToInitial">Whether to reset to initial values.</param>
 	private void FailInitialRateLimitTest(BaseRestRequest request, TaskCompletionSource<bool> ratelimitTcs, bool resetToInitial = false)
 	{
 		if (ratelimitTcs == null && !resetToInitial)
 			return;
 
 		var bucket = request.RateLimitBucket;
 
 		bucket.LimitValid = false;
 		bucket.LimitTestFinished = null;
 		bucket.LimitTesting = 0;
 
 		//Reset to initial values.
 		if (resetToInitial)
 		{
 			this.UpdateHashCaches(request, bucket);
 			bucket.Maximum = 0;
 			bucket.RemainingInternal = 0;
 			return;
 		}
 
 		// no need to wait on all the potentially waiting tasks
 		_ = Task.Run(() => ratelimitTcs.TrySetResult(false));
 	}
 
 	/// <summary>
 	/// Waits for the initial rate limit.
 	/// </summary>
 	/// <param name="bucket">The bucket.</param>
 	private async Task<TaskCompletionSource<bool>> WaitForInitialRateLimit(RateLimitBucket bucket)
 	{
 		while (!bucket.LimitValid)
 		{
 			if (bucket.LimitTesting == 0)
 			{
 				if (Interlocked.CompareExchange(ref bucket.LimitTesting, 1, 0) == 0)
 				{
 					// if we got here when the first request was just finishing, we must not create the waiter task as it would signal ExecuteRequestAsync to bypass rate limiting
 					if (bucket.LimitValid)
 						return null;
 
 					// allow exactly one request to go through without having rate limits available
 					var ratelimitsTcs = new TaskCompletionSource<bool>();
 					bucket.LimitTestFinished = ratelimitsTcs.Task;
 					return ratelimitsTcs;
 				}
 			}
 			// it can take a couple of cycles for the task to be allocated, so wait until it happens or we are no longer probing for the limits
 			Task waitTask = null;
 			while (bucket.LimitTesting != 0 && (waitTask = bucket.LimitTestFinished) == null)
 				await Task.Yield();
 			if (waitTask != null)
 				await waitTask.ConfigureAwait(false);
 
 			// if the request failed and the response did not have rate limit headers we have allow the next request and wait again, thus this is a loop here
 		}
 		return null;
 	}
 
 	/// <summary>
 	/// Builds the request.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <returns>A http request message.</returns>
 	private HttpRequestMessage BuildRequest(BaseRestRequest request)
 	{
 		var req = new HttpRequestMessage(new HttpMethod(request.Method.ToString()), request.Url);
 		if (request.Headers != null && request.Headers.Any())
 			foreach (var kvp in request.Headers)
 				req.Headers.Add(kvp.Key, kvp.Value);
 
 		if (request is RestRequest nmprequest && !string.IsNullOrWhiteSpace(nmprequest.Payload))
 		{
 			this._logger.LogTrace(LoggerEvents.RestTx, nmprequest.Payload);
 
 			req.Content = new StringContent(nmprequest.Payload);
 			req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
 		}
 
 		if (request is MultipartWebRequest mprequest)
 		{
 			this._logger.LogTrace(LoggerEvents.RestTx, "<multipart request>");
 
 			var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
 
 			req.Headers.Add("Connection", "keep-alive");
 			req.Headers.Add("Keep-Alive", "600");
 
 			var content = new MultipartFormDataContent(boundary);
 			if (mprequest.Values != null && mprequest.Values.Any())
 				foreach (var kvp in mprequest.Values)
 					content.Add(new StringContent(kvp.Value), kvp.Key);
 
 			var fileId = mprequest.OverwriteFileIdStart ?? 0;
 
 			if (mprequest.Files != null && mprequest.Files.Any())
 			{
 				foreach (var f in mprequest.Files)
 				{
 					var name = $"files[{fileId.ToString(CultureInfo.InvariantCulture)}]";
 					content.Add(new StreamContent(f.Value), name, f.Key);
 					fileId++;
 				}
 			}
 
 			req.Content = content;
 		}
 
 		if (request is MultipartStickerWebRequest mpsrequest)
 		{
 			this._logger.LogTrace(LoggerEvents.RestTx, "<multipart request>");
 
 			var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
 
 			req.Headers.Add("Connection", "keep-alive");
 			req.Headers.Add("Keep-Alive", "600");
 
 			var sc = new StreamContent(mpsrequest.File.Stream);
 
 			if (mpsrequest.File.ContentType != null)
 				sc.Headers.ContentType = new MediaTypeHeaderValue(mpsrequest.File.ContentType);
 
 			var fileName = mpsrequest.File.FileName;
 
 			if (mpsrequest.File.FileType != null)
 				fileName += '.' + mpsrequest.File.FileType;
 
 			var content = new MultipartFormDataContent(boundary)
 			{
 				{ new StringContent(mpsrequest.Name), "name" },
 				{ new StringContent(mpsrequest.Tags), "tags" },
 				{ new StringContent(mpsrequest.Description), "description" },
 				{ sc, "file", fileName }
 			};
 
 			req.Content = content;
 		}
 		return req;
 	}
 
 	/// <summary>
 	/// Handles the HTTP 429 status.
 	/// </summary>
 	/// <param name="response">The response.</param>
 	/// <param name="waitTask">The wait task.</param>
 	/// <param name="global">If true, global.</param>
 	private void Handle429(RestResponse response, out Task waitTask, out bool global)
 	{
 		waitTask = null;
 		global = false;
 
 		if (response.Headers == null)
 			return;
 		var hs = response.Headers;
 
 		// handle the wait
 		if (hs.TryGetValue("Retry-After", out var retryAfterRaw))
 		{
 			var retryAfter = TimeSpan.FromSeconds(int.Parse(retryAfterRaw, CultureInfo.InvariantCulture));
 			waitTask = Task.Delay(retryAfter);
 		}
 
 		// check if global b1nzy
 		if (hs.TryGetValue("X-RateLimit-Global", out var isGlobal) && isGlobal.ToLowerInvariant() == "true")
 		{
 			// global
 			global = true;
 		}
 	}
 
 	/// <summary>
 	/// Updates the bucket.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
 	/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 	private void UpdateBucket(BaseRestRequest request, RestResponse response, TaskCompletionSource<bool> ratelimitTcs)
 	{
 		var bucket = request.RateLimitBucket;
 
 		if (response.Headers == null)
 		{
 			if (response.ResponseCode != 429) // do not fail when ratelimit was or the next request will be scheduled hitting the rate limit again
 				this.FailInitialRateLimitTest(request, ratelimitTcs);
 			return;
 		}
 
 		var hs = response.Headers;
 
 		if (hs.TryGetValue("X-RateLimit-Scope", out var scope))
 		{
 			bucket.Scope = scope;
 		}
 
 
 		if (hs.TryGetValue("X-RateLimit-Global", out var isGlobal) && isGlobal.ToLowerInvariant() == "true")
 		{
 			if (response.ResponseCode != 429)
 			{
 				bucket.IsGlobal = true;
 				this.FailInitialRateLimitTest(request, ratelimitTcs);
 			}
 
 			return;
 		}
 
 		var r1 = hs.TryGetValue("X-RateLimit-Limit", out var usesMax);
 		var r2 = hs.TryGetValue("X-RateLimit-Remaining", out var usesLeft);
 		var r3 = hs.TryGetValue("X-RateLimit-Reset", out var reset);
 		var r4 = hs.TryGetValue("X-Ratelimit-Reset-After", out var resetAfter);
 		var r5 = hs.TryGetValue("X-Ratelimit-Bucket", out var hash);
 
 		if (!r1 || !r2 || !r3 || !r4)
 		{
 			//If the limits were determined before this request, make the bucket initial again.
 			if (response.ResponseCode != 429)
 				this.FailInitialRateLimitTest(request, ratelimitTcs, ratelimitTcs == null);
 
 			return;
 		}
 
 		var clientTime = DateTimeOffset.UtcNow;
 		var resetTime = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddSeconds(double.Parse(reset, CultureInfo.InvariantCulture));
 		var serverTime = clientTime;
 		if (hs.TryGetValue("Date", out var rawDate))
 			serverTime = DateTimeOffset.Parse(rawDate, CultureInfo.InvariantCulture).ToUniversalTime();
 
 		var resetDelta = resetTime - serverTime;
 		//var difference = clientTime - serverTime;
 		//if (Math.Abs(difference.TotalSeconds) >= 1)
 		////    this.Logger.LogMessage(LogLevel.DebugBaseDiscordClient.RestEventId,  $"Difference between machine and server time: {difference.TotalMilliseconds.ToString("#,##0.00", CultureInfo.InvariantCulture)}ms", DateTime.Now);
 		//else
 		//    difference = TimeSpan.Zero;
 
 		if (request.RateLimitWaitOverride.HasValue)
 			resetDelta = TimeSpan.FromSeconds(request.RateLimitWaitOverride.Value);
 		var newReset = clientTime + resetDelta;
 
 		if (this._useResetAfter)
 		{
 			bucket.ResetAfter = TimeSpan.FromSeconds(double.Parse(resetAfter, CultureInfo.InvariantCulture));
 			newReset = clientTime + bucket.ResetAfter.Value + (request.RateLimitWaitOverride.HasValue
 				? resetDelta
 				: TimeSpan.Zero);
 			bucket.ResetAfterOffset = newReset;
 		}
 		else
 			bucket.Reset = newReset;
 
 		var maximum = int.Parse(usesMax, CultureInfo.InvariantCulture);
 		var remaining = int.Parse(usesLeft, CultureInfo.InvariantCulture);
 
 		if (ratelimitTcs != null)
 		{
 			// initial population of the ratelimit data
 			bucket.SetInitialValues(maximum, remaining, newReset);
 
 			_ = Task.Run(() => ratelimitTcs.TrySetResult(true));
 		}
 		else
 		{
 			// only update the bucket values if this request was for a newer interval than the one
 			// currently in the bucket, to avoid issues with concurrent requests in one bucket
 			// remaining is reset by TryResetLimit and not the response, just allow that to happen when it is time
 			if (bucket.NextReset == 0)
 				bucket.NextReset = newReset.UtcTicks;
 		}
 
 		this.UpdateHashCaches(request, bucket, hash);
 	}
 
 	/// <summary>
 	/// Updates the hash caches.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="bucket">The bucket.</param>
 	/// <param name="newHash">The new hash.</param>
 	private void UpdateHashCaches(BaseRestRequest request, RateLimitBucket bucket, string newHash = null)
 	{
 		var hashKey = RateLimitBucket.GenerateHashKey(request.Method, request.Route);
 
 		if (!this._routesToHashes.TryGetValue(hashKey, out var oldHash))
 			return;
 
 		// This is an unlimited bucket, which we don't need to keep track of.
 		if (newHash == null)
 		{
 			_ = this._routesToHashes.TryRemove(hashKey, out _);
 			_ = this._hashesToBuckets.TryRemove(bucket.BucketId, out _);
 			return;
 		}
 
 		// Only update the hash once, due to a bug on Discord's end.
 		// This will cause issues if the bucket hashes are dynamically changed from the API while running,
 		// in which case, Dispose will need to be called to clear the caches.
 		if (bucket.IsUnlimited && newHash != oldHash)
 		{
 			this._logger.LogDebug(LoggerEvents.RestHashMover, "Updating hash in {0}: \"{1}\" -> \"{2}\"", hashKey, oldHash, newHash);
 			var bucketId = RateLimitBucket.GenerateBucketId(newHash, bucket.GuildId, bucket.ChannelId, bucket.WebhookId);
 
 			_ = this._routesToHashes.AddOrUpdate(hashKey, newHash, (key, oldHash) =>
 			{
 				bucket.Hash = newHash;
 
 				var oldBucketId = RateLimitBucket.GenerateBucketId(oldHash, bucket.GuildId, bucket.ChannelId, bucket.WebhookId);
 
 				// Remove the old unlimited bucket.
 				_ = this._hashesToBuckets.TryRemove(oldBucketId, out _);
 				_ = this._hashesToBuckets.AddOrUpdate(bucketId, bucket, (key, oldBucket) => bucket);
 
 				return newHash;
 			});
 		}
 
 		return;
 	}
 
 	/// <summary>
 	/// Cleans the buckets.
 	/// </summary>
 	private async Task CleanupBucketsAsync()
 	{
 		while (!this._bucketCleanerTokenSource.IsCancellationRequested)
 		{
 			try
 			{
 				await Task.Delay(this._bucketCleanupDelay, this._bucketCleanerTokenSource.Token).ConfigureAwait(false);
 			}
 			catch { }
 
 			if (this._disposed)
 				return;
 
 			//Check and clean request queue first in case it wasn't removed properly during requests.
 			foreach (var key in this._requestQueue.Keys)
 			{
 				var bucket = this._hashesToBuckets.Values.FirstOrDefault(x => x.RouteHashes.Contains(key));
 
 				if (bucket == null || (bucket != null && bucket.LastAttemptAt.AddSeconds(5) < DateTimeOffset.UtcNow))
 					_ = this._requestQueue.TryRemove(key, out _);
 			}
 
 			var removedBuckets = 0;
 			StringBuilder bucketIdStrBuilder = default;
 
 			foreach (var kvp in this._hashesToBuckets)
 			{
 				bucketIdStrBuilder ??= new StringBuilder();
 
 				var key = kvp.Key;
 				var value = kvp.Value;
 
 				// Don't remove the bucket if it's currently being handled by the rest client, unless it's an unlimited bucket.
 				if (this._requestQueue.ContainsKey(value.BucketId) && !value.IsUnlimited)
 					continue;
 
 				var resetOffset = this._useResetAfter ? value.ResetAfterOffset : value.Reset;
 
 				// Don't remove the bucket if it's reset date is less than now + the additional wait time, unless it's an unlimited bucket.
 				if (!value.IsUnlimited && (resetOffset > DateTimeOffset.UtcNow || DateTimeOffset.UtcNow - resetOffset < this._bucketCleanupDelay))
 					continue;
 
 				_ = this._hashesToBuckets.TryRemove(key, out _);
 				removedBuckets++;
 				bucketIdStrBuilder.Append(value.BucketId + ", ");
 			}
 
 			if (removedBuckets > 0)
 				this._logger.LogDebug(LoggerEvents.RestCleaner, "Removed {0} unused bucket{1}: [{2}]", removedBuckets, removedBuckets > 1 ? "s" : string.Empty, bucketIdStrBuilder.ToString().TrimEnd(',', ' '));
 
 			if (this._hashesToBuckets.IsEmpty)
 				break;
 		}
 
 		if (!this._bucketCleanerTokenSource.IsCancellationRequested)
 			this._bucketCleanerTokenSource.Cancel();
 
 		this._cleanerRunning = false;
 		this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task stopped.");
 	}
 
 	~RestClient()
 	{
 		this.Dispose();
 	}
 
 	/// <summary>
 	/// Disposes the rest client.
 	/// </summary>
 	public void Dispose()
 	{
 		if (this._disposed)
 			return;
 
 		this._disposed = true;
 
 		this._globalRateLimitEvent.Reset();
 
 		if (this._bucketCleanerTokenSource?.IsCancellationRequested == false)
 		{
 			this._bucketCleanerTokenSource?.Cancel();
 			this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task stopped.");
 		}
 
 		try
 		{
 			this._cleanerTask?.Dispose();
 			this._bucketCleanerTokenSource?.Dispose();
 			this.HttpClient?.Dispose();
 		}
 		catch { }
 
 		this._routesToHashes.Clear();
 		this._hashesToBuckets.Clear();
 		this._requestQueue.Clear();
 		GC.SuppressFinalize(this);
 	}
 }
diff --git a/_appveyor_old.yml b/_appveyor_old.yml
deleted file mode 100644
index ba16ccca4..000000000
--- a/_appveyor_old.yml
+++ /dev/null
@@ -1,140 +0,0 @@
--
-  branches:
-    only:
-    - disabled
-  version: 10.1.1-nightly-{build}
-  pull_requests:
-    do_not_increment_build_number: true
-  skip_tags: true
-  max_jobs: 1
-  image: Visual Studio 2022
-  clone_depth: 1
-  build_script:
-  - ps: |-
-      # Version number
-      $BUILD_NUMBER = [int]$Env:APPVEYOR_BUILD_NUMBER
-      $BUILD_SUFFIX = "nightly"
-
-      # Branch
-      $BRANCH = "$Env:APPVEYOR_REPO_BRANCH"
-      $Env:DOCFX_SOURCE_BRANCH_NAME = "$BRANCH"
-
-      # Output directory
-      $Env:ARTIFACT_DIR = ".\artifacts"
-      $dir = New-Item -type directory $env:ARTIFACT_DIR
-      $dir = $dir.FullName
-
-      # Verbosity
-      Write-Host "Build: $BUILD_NUMBER / Branch: $BRANCH"
-      Write-Host "Artifacts will be placed in: $dir"
-
-      # Check if this is a PR
-      if (-not $Env:APPVEYOR_PULL_REQUEST_NUMBER)
-      {
-          Write-Host "Commencing complete build"
-          & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
-          & Remove-Item "$dir\*.symbols.nupkg"
-      }
-      else
-      {
-          Write-Host "Building from PR ($Env:APPVEYOR_PULL_REQUEST_NUMBER)"
-          & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
-          & Remove-Item "$dir\*.symbols.nupkg"
-      }
-  artifacts:
-  - path: artifacts\*.snupkg
-  - path: artifacts\*.nupkg
-  - path: artifacts\dcs-docs.tar.xz
-  deploy:
-  - provider: NuGet
-    server:
-    api_key:
-      secure: RjohrwOJE0RgzgIfe71AH42hRr7aZnEz5So/EKRI1FM7LQ/SLrEwSTDsNEQWMQik
-    skip_symbols: false
-  - provider: GitHub
-    auth_token:
-      secure: oMF8sv9mhVjO7pBctQOwlmfd5aHQ4hvMoVCz77bgO9+1zBQSelPHxk0bCVfXNCCp
-    prerelease: true
-    force_update: true
-  - provider: NuGet
-    server: https://nuget.pkg.github.com/Aiko-IT-Systems/index.json
-    username: lulalaby
-    api_key:
-      secure: SBGo8KrGJ7t5wwMNHKD0WSzrQ+PLJbqXE3FtDH2yGkSrQewO+kzmwp/xGk5a84He
-    skip_symbols: true
-  on_success:
-    - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
-    - ps: ./send.ps1 success $env:WEBHOOK_URL
-  on_failure:
-    - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
-    - ps: ./send.ps1 failure $env:WEBHOOK_URL
-# Releases
--
-  branches:
-    only:
-    - /fuck/
-  version: 10.1.0
-  pull_requests:
-    do_not_increment_build_number: true
-  skip_tags: true
-  max_jobs: 1
-  image: Visual Studio 2022
-  clone_depth: 1
-  build_script:
-  - ps: |-
-      # Version number
-      $BUILD_NUMBER = [int]$Env:APPVEYOR_BUILD_NUMBER
-
-      # Branch
-      $BRANCH = "$Env:APPVEYOR_REPO_BRANCH"
-      $Env:DOCFX_SOURCE_BRANCH_NAME = "$BRANCH"
-
-      # Output directory
-      $Env:ARTIFACT_DIR = ".\artifacts"
-      $dir = New-Item -type directory $env:ARTIFACT_DIR
-      $dir = $dir.FullName
-
-      # Verbosity
-      Write-Host "Build: $BUILD_NUMBER / Branch: $BRANCH"
-      Write-Host "Artifacts will be placed in: $dir"
-
-      # Check if this is a PR
-      if (-not $Env:APPVEYOR_PULL_REQUEST_NUMBER)
-      {
-          Write-Host "Commencing complete build"
-          & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
-          & Remove-Item "$dir\*.symbols.nupkg"
-      }
-      else
-      {
-          Write-Host "Building from PR ($Env:APPVEYOR_PULL_REQUEST_NUMBER)"
-          & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
-          & Remove-Item "$dir\*.symbols.nupkg"
-      }
-  artifacts:
-  - path: artifacts\*.snupkg
-  - path: artifacts\*.nupkg
-  - path: artifacts\dcs-docs.tar.xz
-  deploy:
-  - provider: NuGet
-    server:
-    api_key:
-      secure: RjohrwOJE0RgzgIfe71AH42hRr7aZnEz5So/EKRI1FM7LQ/SLrEwSTDsNEQWMQik
-    skip_symbols: false
-  - provider: GitHub
-    auth_token:
-      secure: oMF8sv9mhVjO7pBctQOwlmfd5aHQ4hvMoVCz77bgO9+1zBQSelPHxk0bCVfXNCCp
-    prerelease: false
-    force_update: true
-  - provider: NuGet
-    server: https://nuget.pkg.github.com/Aiko-IT-Systems/index.json
-    username: lulalaby
-    api_key:
-      secure: SBGo8KrGJ7t5wwMNHKD0WSzrQ+PLJbqXE3FtDH2yGkSrQewO+kzmwp/xGk5a84He
-    skip_symbols: true
-  on_success:
-    - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
-    - ps: ./send.ps1 success $env:WEBHOOK_URL
-  on_failure:
-    - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
-    - ps: ./send.ps1 failure $env:WEBHOOK_URL