diff --git a/DisCatSharp.CommandsNext/CommandsNextExtension.cs b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
index e9447807a..717168ad7 100644
--- a/DisCatSharp.CommandsNext/CommandsNextExtension.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
@@ -1,1086 +1,1086 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Builders;
 using DisCatSharp.CommandsNext.Converters;
 using DisCatSharp.CommandsNext.Entities;
 using DisCatSharp.CommandsNext.Exceptions;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.CommandsNext;
 
 /// <summary>
 /// This is the class which handles command registration, management, and execution.
 /// </summary>
 public class CommandsNextExtension : BaseExtension
 {
 	/// <summary>
 	/// Gets the config.
 	/// </summary>
 	private readonly CommandsNextConfiguration _config;
 
 	/// <summary>
 	/// Gets the help formatter.
 	/// </summary>
 	private readonly HelpFormatterFactory _helpFormatter;
 
 	/// <summary>
 	/// Gets the convert generic.
 	/// </summary>
 	private readonly MethodInfo _convertGeneric;
 
 	/// <summary>
 	/// Gets the user friendly type names.
 	/// </summary>
 	private readonly Dictionary<Type, string> _userFriendlyTypeNames;
 	/// <summary>
 	/// Gets the argument converters.
 	/// </summary>
 	internal Dictionary<Type, IArgumentConverter> ArgumentConverters { get; }
 
 	/// <summary>
 	/// Gets the service provider this CommandsNext module was configured with.
 	/// </summary>
 	public IServiceProvider Services
 		=> this._config.ServiceProvider;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="CommandsNextExtension"/> class.
 	/// </summary>
 	/// <param name="cfg">The cfg.</param>
 	internal CommandsNextExtension(CommandsNextConfiguration cfg)
 	{
 		this._config = new CommandsNextConfiguration(cfg);
 		this._topLevelCommands = new Dictionary<string, Command>();
 		this._registeredCommandsLazy = new Lazy<IReadOnlyDictionary<string, Command>>(() => new ReadOnlyDictionary<string, Command>(this._topLevelCommands));
 		this._helpFormatter = new HelpFormatterFactory();
 		this._helpFormatter.SetFormatterType<DefaultHelpFormatter>();
 
 		this.ArgumentConverters = new Dictionary<Type, IArgumentConverter>
 		{
 			[typeof(string)] = new StringConverter(),
 			[typeof(bool)] = new BoolConverter(),
 			[typeof(sbyte)] = new Int8Converter(),
 			[typeof(byte)] = new Uint8Converter(),
 			[typeof(short)] = new Int16Converter(),
 			[typeof(ushort)] = new Uint16Converter(),
 			[typeof(int)] = new Int32Converter(),
 			[typeof(uint)] = new Uint32Converter(),
 			[typeof(long)] = new Int64Converter(),
 			[typeof(ulong)] = new Uint64Converter(),
 			[typeof(float)] = new Float32Converter(),
 			[typeof(double)] = new Float64Converter(),
 			[typeof(decimal)] = new Float128Converter(),
 			[typeof(DateTime)] = new DateTimeConverter(),
 			[typeof(DateTimeOffset)] = new DateTimeOffsetConverter(),
 			[typeof(TimeSpan)] = new TimeSpanConverter(),
 			[typeof(Uri)] = new UriConverter(),
 			[typeof(DiscordUser)] = new DiscordUserConverter(),
 			[typeof(DiscordMember)] = new DiscordMemberConverter(),
 			[typeof(DiscordRole)] = new DiscordRoleConverter(),
 			[typeof(DiscordChannel)] = new DiscordChannelConverter(),
 			[typeof(DiscordGuild)] = new DiscordGuildConverter(),
 			[typeof(DiscordMessage)] = new DiscordMessageConverter(),
 			[typeof(DiscordEmoji)] = new DiscordEmojiConverter(),
 			[typeof(DiscordThreadChannel)] = new DiscordThreadChannelConverter(),
 			[typeof(DiscordInvite)] = new DiscordInviteConverter(),
 			[typeof(DiscordColor)] = new DiscordColorConverter(),
 			[typeof(DiscordScheduledEvent)] = new DiscordScheduledEventConverter(),
 		};
 
 		this._userFriendlyTypeNames = new Dictionary<Type, string>()
 		{
 			[typeof(string)] = "string",
 			[typeof(bool)] = "boolean",
 			[typeof(sbyte)] = "signed byte",
 			[typeof(byte)] = "byte",
 			[typeof(short)] = "short",
 			[typeof(ushort)] = "unsigned short",
 			[typeof(int)] = "int",
 			[typeof(uint)] = "unsigned int",
 			[typeof(long)] = "long",
 			[typeof(ulong)] = "unsigned long",
 			[typeof(float)] = "float",
 			[typeof(double)] = "double",
 			[typeof(decimal)] = "decimal",
 			[typeof(DateTime)] = "date and time",
 			[typeof(DateTimeOffset)] = "date and time",
 			[typeof(TimeSpan)] = "time span",
 			[typeof(Uri)] = "URL",
 			[typeof(DiscordUser)] = "user",
 			[typeof(DiscordMember)] = "member",
 			[typeof(DiscordRole)] = "role",
 			[typeof(DiscordChannel)] = "channel",
 			[typeof(DiscordGuild)] = "guild",
 			[typeof(DiscordMessage)] = "message",
 			[typeof(DiscordEmoji)] = "emoji",
 			[typeof(DiscordThreadChannel)] = "thread",
 			[typeof(DiscordInvite)] = "invite",
 			[typeof(DiscordColor)] = "color",
 			[typeof(DiscordScheduledEvent)] = "event"
 		};
 
 		foreach (var xt in this.ArgumentConverters.Keys.ToArray())
 		{
 			var xti = xt.GetTypeInfo();
 			if (!xti.IsValueType)
 				continue;
 
 			var xcvt = typeof(NullableConverter<>).MakeGenericType(xt);
 			var xnt = typeof(Nullable<>).MakeGenericType(xt);
 			if (this.ArgumentConverters.ContainsKey(xcvt))
 				continue;
 
 			var xcv = Activator.CreateInstance(xcvt) as IArgumentConverter;
 			this.ArgumentConverters[xnt] = xcv;
 			this._userFriendlyTypeNames[xnt] = this._userFriendlyTypeNames[xt];
 		}
 
 		var t = this.GetType();
 		var ms = t.GetTypeInfo().DeclaredMethods;
 		var m = ms.FirstOrDefault(xm => xm.Name == "ConvertArgumentToObj" && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPrivate);
 		this._convertGeneric = m;
 	}
 
 	/// <summary>
 	/// Sets the help formatter to use with the default help command.
 	/// </summary>
 	/// <typeparam name="T">Type of the formatter to use.</typeparam>
 	public void SetHelpFormatter<T>() where T : BaseHelpFormatter => this._helpFormatter.SetFormatterType<T>();
 
 	#region DiscordClient Registration
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
-	/// <exception cref="System.InvalidOperationException"/>
+	/// <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);
 
 		if (this._userFriendlyTypeNames.ContainsKey(t))
 			this._userFriendlyTypeNames.Remove(t);
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		if (!this.ArgumentConverters.ContainsKey(nullableType))
 			return;
 
 		this.ArgumentConverters.Remove(nullableType);
 		this._userFriendlyTypeNames.Remove(nullableType);
 	}
 
 	/// <summary>
 	/// Registers a user-friendly type name.
 	/// </summary>
 	/// <typeparam name="T">Type to register the name for.</typeparam>
 	/// <param name="value">Name to register.</param>
 	public void RegisterUserFriendlyTypeName<T>(string value)
 	{
 		if (string.IsNullOrWhiteSpace(value))
 			throw new ArgumentNullException(nameof(value), "Name cannot be null or empty.");
 
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
 		if (!this.ArgumentConverters.ContainsKey(t))
 			throw new InvalidOperationException("Cannot register a friendly name for a type which has no associated converter.");
 
 		this._userFriendlyTypeNames[t] = value;
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		this._userFriendlyTypeNames[nullableType] = value;
 	}
 
 	/// <summary>
 	/// Converts a type into user-friendly type name.
 	/// </summary>
 	/// <param name="t">Type to convert.</param>
 	/// <returns>User-friendly type name.</returns>
 	public string GetUserFriendlyTypeName(Type t)
 	{
 		if (this._userFriendlyTypeNames.ContainsKey(t))
 			return this._userFriendlyTypeNames[t];
 
 		var ti = t.GetTypeInfo();
 		if (ti.IsGenericTypeDefinition && t.GetGenericTypeDefinition() == typeof(Nullable<>))
 		{
 			var tn = ti.GenericTypeArguments[0];
 			return this._userFriendlyTypeNames.ContainsKey(tn) ? this._userFriendlyTypeNames[tn] : tn.Name;
 		}
 
 		return t.Name;
 	}
 	#endregion
 
 	#region Helpers
 	/// <summary>
 	/// Allows easier interoperability with reflection by turning the <see cref="Task{T}"/> returned by <see cref="ConvertArgument"/>
 	/// into a task containing <see cref="object"/>, using the provided generic type information.
 	/// </summary>
 	private async Task<object> ConvertArgumentToObj<T>(string value, CommandContext ctx)
 		=> await this.ConvertArgument<T>(value, ctx).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets the configuration-specific string comparer. This returns <see cref="StringComparer.Ordinal"/> or <see cref="StringComparer.OrdinalIgnoreCase"/>,
 	/// depending on whether <see cref="CommandsNextConfiguration.CaseSensitive"/> is set to <see langword="true"/> or <see langword="false"/>.
 	/// </summary>
 	/// <returns>A string comparer.</returns>
 	internal IEqualityComparer<string> GetStringComparer()
 		=> this._config.CaseSensitive
 			? StringComparer.Ordinal
 			: StringComparer.OrdinalIgnoreCase;
 	#endregion
 
 	#region Events
 	/// <summary>
 	/// Triggered whenever a command executes successfully.
 	/// </summary>
 	public event AsyncEventHandler<CommandsNextExtension, CommandExecutionEventArgs> CommandExecuted
 	{
 		add => this._executed.Register(value);
 		remove => this._executed.Unregister(value);
 	}
 	private AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs> _executed;
 
 	/// <summary>
 	/// Triggered whenever a command throws an exception during execution.
 	/// </summary>
 	public event AsyncEventHandler<CommandsNextExtension, CommandErrorEventArgs> CommandErrored
 	{
 		add => this._error.Register(value);
 		remove => this._error.Unregister(value);
 	}
 	private AsyncEvent<CommandsNextExtension, CommandErrorEventArgs> _error;
 
 	/// <summary>
 	/// Fires when a command gets executed.
 	/// </summary>
 	/// <param name="e">The command execution event arguments.</param>
 	private Task OnCommandExecuted(CommandExecutionEventArgs e)
 		=> this._executed.InvokeAsync(this, e);
 
 	/// <summary>
 	/// Fires when a command fails.
 	/// </summary>
 	/// <param name="e">The command error event arguments.</param>
 	private Task OnCommandErrored(CommandErrorEventArgs e)
 		=> this._error.InvokeAsync(this, e);
 	#endregion
 }
diff --git a/DisCatSharp.Common/Attributes/DateTimeFormatAttribute.cs b/DisCatSharp.Common/Attributes/DateTimeFormatAttribute.cs
index c2c2232d6..adb5c3447 100644
--- a/DisCatSharp.Common/Attributes/DateTimeFormatAttribute.cs
+++ b/DisCatSharp.Common/Attributes/DateTimeFormatAttribute.cs
@@ -1,132 +1,132 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 // ReSharper disable InconsistentNaming
 
 namespace DisCatSharp.Common.Serialization;
 
 /// <summary>
-/// Defines the format for string-serialized <see cref="System.DateTime"/> and <see cref="System.DateTimeOffset"/> objects.
+/// Defines the format for string-serialized <see cref="DateTime"/> and <see cref="DateTimeOffset"/> objects.
 /// </summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class DateTimeFormatAttribute : SerializationAttribute
 {
 	/// <summary>
 	/// Gets the ISO 8601 format string of "yyyy-MM-ddTHH:mm:ss.fffzzz".
 	/// </summary>
 	public const string FORMAT_ISO_8601 = "yyyy-MM-ddTHH:mm:ss.fffzzz";
 
 	/// <summary>
 	/// Gets the RFC 1123 format string of "R".
 	/// </summary>
 	public const string FORMAT_RFC_1123 = "R";
 
 	/// <summary>
 	/// Gets the general long format.
 	/// </summary>
 	public const string FORMAT_LONG = "G";
 
 	/// <summary>
 	/// Gets the general short format.
 	/// </summary>
 	public const string FORMAT_SHORT = "g";
 
 	/// <summary>
 	/// Gets the custom datetime format string to use.
 	/// </summary>
 	public string Format { get; }
 
 	/// <summary>
 	/// Gets the predefined datetime format kind.
 	/// </summary>
 	public DateTimeFormatKind Kind { get; }
 
 	/// <summary>
 	/// Specifies a predefined format to use.
 	/// </summary>
 	/// <param name="kind">Predefined format kind to use.</param>
 	public DateTimeFormatAttribute(DateTimeFormatKind kind)
 	{
 		if (kind < 0 || kind > DateTimeFormatKind.InvariantLocaleShort)
 			throw new ArgumentOutOfRangeException(nameof(kind), "Specified format kind is not legal or supported.");
 
 		this.Kind = kind;
 		this.Format = null;
 	}
 
 	/// <summary>
 	/// <para>Specifies a custom format to use.</para>
 	/// <para>See https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings for more details.</para>
 	/// </summary>
 	/// <param name="format">Custom format string to use.</param>
 	public DateTimeFormatAttribute(string format)
 	{
 		if (string.IsNullOrWhiteSpace(format))
 			throw new ArgumentNullException(nameof(format), "Specified format cannot be null or empty.");
 
 		this.Kind = DateTimeFormatKind.Custom;
 		this.Format = format;
 	}
 }
 
 /// <summary>
-/// <para>Defines which built-in format to use for for <see cref="System.DateTime"/> and <see cref="System.DateTimeOffset"/> serialization.</para>
+/// <para>Defines which built-in format to use for for <see cref="DateTime"/> and <see cref="System.DateTimeOffset"/> serialization.</para>
 /// <para>See https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings and https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings for more details.</para>
 /// </summary>
 public enum DateTimeFormatKind : int
 {
 	/// <summary>
 	/// Specifies ISO 8601 format, which is equivalent to .NET format string of "yyyy-MM-ddTHH:mm:ss.fffzzz".
 	/// </summary>
 	ISO8601 = 0,
 
 	/// <summary>
 	/// Specifies RFC 1123 format, which is equivalent to .NET format string of "R".
 	/// </summary>
 	RFC1123 = 1,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.CurrentCulture"/>, with a format string of "G". This format is not recommended for portability reasons.
 	/// </summary>
 	CurrentLocaleLong = 2,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.CurrentCulture"/>, with a format string of "g". This format is not recommended for portability reasons.
 	/// </summary>
 	CurrentLocaleShort = 3,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.InvariantCulture"/>, with a format string of "G".
 	/// </summary>
 	InvariantLocaleLong = 4,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.InvariantCulture"/>, with a format string of "g".
 	/// </summary>
 	InvariantLocaleShort = 5,
 
 	/// <summary>
 	/// Specifies a custom format. This value is not usable directly.
 	/// </summary>
 	Custom = int.MaxValue
 }
diff --git a/DisCatSharp.Common/Attributes/TimeSpanAttributes.cs b/DisCatSharp.Common/Attributes/TimeSpanAttributes.cs
index af1e257ed..b5b123fba 100644
--- a/DisCatSharp.Common/Attributes/TimeSpanAttributes.cs
+++ b/DisCatSharp.Common/Attributes/TimeSpanAttributes.cs
@@ -1,41 +1,41 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 namespace DisCatSharp.Common.Serialization;
 
 /// <summary>
-/// <para>Specifies that this <see cref="System.TimeSpan"/> will be serialized as a number of whole seconds.</para>
+/// <para>Specifies that this <see cref="TimeSpan"/> will be serialized as a number of whole seconds.</para>
 /// <para>This value will always be serialized as a number.</para>
 /// </summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class TimeSpanSecondsAttribute : SerializationAttribute
 { }
 
 /// <summary>
-/// <para>Specifies that this <see cref="System.TimeSpan"/> will be serialized as a number of whole milliseconds.</para>
+/// <para>Specifies that this <see cref="TimeSpan"/> will be serialized as a number of whole milliseconds.</para>
 /// <para>This value will always be serialized as a number.</para>
 /// </summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class TimeSpanMillisecondsAttribute : SerializationAttribute
 { }
diff --git a/DisCatSharp.Common/Attributes/TimeSpanFormatAttribute.cs b/DisCatSharp.Common/Attributes/TimeSpanFormatAttribute.cs
index af570ce41..850614912 100644
--- a/DisCatSharp.Common/Attributes/TimeSpanFormatAttribute.cs
+++ b/DisCatSharp.Common/Attributes/TimeSpanFormatAttribute.cs
@@ -1,132 +1,132 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 // ReSharper disable InconsistentNaming
 
 namespace DisCatSharp.Common.Serialization;
 
 /// <summary>
-/// Defines the format for string-serialized <see cref="System.TimeSpan"/> objects.
+/// Defines the format for string-serialized <see cref="TimeSpan"/> objects.
 /// </summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class TimeSpanFormatAttribute : SerializationAttribute
 {
 	/// <summary>
 	/// Gets the ISO 8601 format string of @"ddThh\:mm\:ss\.fff".
 	/// </summary>
 	public const string FORMAT_ISO_8601 = @"ddThh\:mm\:ss\.fff";
 
 	/// <summary>
 	/// Gets the constant format.
 	/// </summary>
 	public const string FORMAT_CONSTANT = "c";
 
 	/// <summary>
 	/// Gets the general long format.
 	/// </summary>
 	public const string FORMAT_LONG = "G";
 
 	/// <summary>
 	/// Gets the general short format.
 	/// </summary>
 	public const string FORMAT_SHORT = "g";
 
 	/// <summary>
 	/// Gets the custom datetime format string to use.
 	/// </summary>
 	public string Format { get; }
 
 	/// <summary>
 	/// Gets the predefined datetime format kind.
 	/// </summary>
 	public TimeSpanFormatKind Kind { get; }
 
 	/// <summary>
 	/// Specifies a predefined format to use.
 	/// </summary>
 	/// <param name="kind">Predefined format kind to use.</param>
 	public TimeSpanFormatAttribute(TimeSpanFormatKind kind)
 	{
 		if (kind < 0 || kind > TimeSpanFormatKind.InvariantLocaleShort)
 			throw new ArgumentOutOfRangeException(nameof(kind), "Specified format kind is not legal or supported.");
 
 		this.Kind = kind;
 		this.Format = null;
 	}
 
 	/// <summary>
 	/// <para>Specifies a custom format to use.</para>
 	/// <para>See https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-timespan-format-strings for more details.</para>
 	/// </summary>
 	/// <param name="format">Custom format string to use.</param>
 	public TimeSpanFormatAttribute(string format)
 	{
 		if (string.IsNullOrWhiteSpace(format))
 			throw new ArgumentNullException(nameof(format), "Specified format cannot be null or empty.");
 
 		this.Kind = TimeSpanFormatKind.Custom;
 		this.Format = format;
 	}
 }
 
 /// <summary>
-/// <para>Defines which built-in format to use for <see cref="System.TimeSpan"/> serialization.</para>
+/// <para>Defines which built-in format to use for <see cref="TimeSpan"/> serialization.</para>
 /// <para>See https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings and https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-timespan-format-strings for more details.</para>
 /// </summary>
 public enum TimeSpanFormatKind : int
 {
 	/// <summary>
 	/// Specifies ISO 8601-like time format, which is equivalent to .NET format string of @"ddThh\:mm\:ss\.fff".
 	/// </summary>
 	ISO8601 = 0,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.InvariantCulture"/>, with a format string of "c".
 	/// </summary>
 	InvariantConstant = 1,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.CurrentCulture"/>, with a format string of "G". This format is not recommended for portability reasons.
 	/// </summary>
 	CurrentLocaleLong = 2,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.CurrentCulture"/>, with a format string of "g". This format is not recommended for portability reasons.
 	/// </summary>
 	CurrentLocaleShort = 3,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.InvariantCulture"/>, with a format string of "G". This format is not recommended for portability reasons.
 	/// </summary>
 	InvariantLocaleLong = 4,
 
 	/// <summary>
 	/// Specifies a format defined by <see cref="System.Globalization.CultureInfo.InvariantCulture"/>, with a format string of "g". This format is not recommended for portability reasons.
 	/// </summary>
 	InvariantLocaleShort = 5,
 
 	/// <summary>
 	/// Specifies a custom format. This value is not usable directly.
 	/// </summary>
 	Custom = int.MaxValue
 }
diff --git a/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs b/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs
index cf3b9aed8..32144740a 100644
--- a/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs
+++ b/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs
@@ -1,41 +1,41 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 namespace DisCatSharp.Common.Serialization;
 
 /// <summary>
-/// <para>Specifies that this <see cref="System.DateTime"/> or <see cref="System.DateTimeOffset"/> will be serialized as Unix timestamp seconds.</para>
+/// <para>Specifies that this <see cref="DateTime"/> or <see cref="DateTimeOffset"/> will be serialized as Unix timestamp seconds.</para>
 /// <para>This value will always be serialized as a number.</para>
 /// </summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class UnixSecondsAttribute : SerializationAttribute
 { }
 
 /// <summary>
-/// <para>Specifies that this <see cref="System.DateTime"/> or <see cref="System.DateTimeOffset"/> will be serialized as Unix timestamp milliseconds.</para>
+/// <para>Specifies that this <see cref="DateTime"/> or <see cref="DateTimeOffset"/> will be serialized as Unix timestamp milliseconds.</para>
 /// <para>This value will always be serialized as a number.</para>
 /// </summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class UnixMillisecondsAttribute : SerializationAttribute
 { }
diff --git a/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs b/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs
index 3ace497bc..75e2141ea 100644
--- a/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs
+++ b/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs
@@ -1,813 +1,813 @@
 // 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;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
 namespace DisCatSharp.Common;
 
 /// <summary>
-/// Represents collection of string keys and <typeparamref name="TValue"/> values, allowing the use of <see cref="System.ReadOnlySpan{T}"/> for dictionary operations.
+/// Represents collection of string keys and <typeparamref name="TValue"/> values, allowing the use of <see cref="ReadOnlySpan{T}"/> for dictionary operations.
 /// </summary>
 /// <typeparam name="TValue">Type of items in this dictionary.</typeparam>
 public sealed class CharSpanLookupDictionary<TValue> :
 	IDictionary<string, TValue>,
 	IReadOnlyDictionary<string, TValue>,
 	IDictionary
 {
 	/// <summary>
 	/// Gets the collection of all keys present in this dictionary.
 	/// </summary>
 	public IEnumerable<string> Keys => this.GetKeysInternal();
 	/// <summary>
 	/// Gets the keys.
 	/// </summary>
 	ICollection<string> IDictionary<string, TValue>.Keys => this.GetKeysInternal();
 	/// <summary>
 	/// Gets the keys.
 	/// </summary>
 	ICollection IDictionary.Keys => this.GetKeysInternal();
 
 	/// <summary>
 	/// Gets the collection of all values present in this dictionary.
 	/// </summary>
 	public IEnumerable<TValue> Values => this.GetValuesInternal();
 	/// <summary>
 	/// Gets the values.
 	/// </summary>
 	ICollection<TValue> IDictionary<string, TValue>.Values => this.GetValuesInternal();
 	/// <summary>
 	/// Gets the values.
 	/// </summary>
 	ICollection IDictionary.Values => this.GetValuesInternal();
 
 	/// <summary>
 	/// Gets the total number of items in this dictionary.
 	/// </summary>
 	public int Count { get; private set; }
 
 	/// <summary>
 	/// Gets whether this dictionary is read-only.
 	/// </summary>
 	public bool IsReadOnly => false;
 
 	/// <summary>
 	/// Gets whether this dictionary has a fixed size.
 	/// </summary>
 	public bool IsFixedSize => false;
 
 	/// <summary>
 	/// Gets whether this dictionary is considered thread-safe.
 	/// </summary>
 	public bool IsSynchronized => false;
 
 	/// <summary>
 	/// Gets the object which allows synchronizing access to this dictionary.
 	/// </summary>
 	public object SyncRoot { get; } = new();
 
 	/// <summary>
 	/// Gets or sets a value corresponding to given key in this dictionary.
 	/// </summary>
 	/// <param name="key">Key to get or set the value for.</param>
 	/// <returns>Value matching the supplied key, if applicable.</returns>
 	public TValue this[string key]
 	{
 		get
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key));
 
 			if (!this.TryRetrieveInternal(key.AsSpan(), out var value))
 				throw new KeyNotFoundException($"The given key '{key}' was not present in the dictionary.");
 
 			return value;
 		}
 
 		set
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key));
 
 			this.TryInsertInternal(key, value, true);
 		}
 	}
 
 	/// <summary>
 	/// Gets or sets a value corresponding to given key in this dictionary.
 	/// </summary>
 	/// <param name="key">Key to get or set the value for.</param>
 	/// <returns>Value matching the supplied key, if applicable.</returns>
 	public TValue this[ReadOnlySpan<char> key]
 	{
 		get
 		{
 			if (!this.TryRetrieveInternal(key, out var value))
 				throw new KeyNotFoundException($"The given key was not present in the dictionary.");
 
 			return value;
 		}
 
 		set
 		{
 			unsafe
 			{
 				fixed (char* chars = &key.GetPinnableReference())
 					this.TryInsertInternal(new string(chars, 0, key.Length), value, true);
 			}
 		}
 	}
 
 	object IDictionary.this[object key]
 	{
 		get
 		{
 			if (!(key is string tkey))
 				throw new ArgumentException("Key needs to be an instance of a string.");
 
 			if (!this.TryRetrieveInternal(tkey.AsSpan(), out var value))
 				throw new KeyNotFoundException($"The given key '{tkey}' was not present in the dictionary.");
 
 			return value;
 		}
 
 		set
 		{
 			if (!(key is string tkey))
 				throw new ArgumentException("Key needs to be an instance of a string.");
 
 			if (!(value is TValue tvalue))
 			{
 				tvalue = default;
 				if (tvalue != null)
 					throw new ArgumentException($"Value needs to be an instance of {typeof(TValue)}.");
 			}
 
 			this.TryInsertInternal(tkey, tvalue, true);
 		}
 	}
 
 	/// <summary>
 	/// Gets the internal buckets.
 	/// </summary>
 	private readonly Dictionary<ulong, KeyedValue> _internalBuckets;
 
 	/// <summary>
 	/// Creates a new, empty <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/>.
 	/// </summary>
 	public CharSpanLookupDictionary()
 	{
 		this._internalBuckets = new Dictionary<ulong, KeyedValue>();
 	}
 
 	/// <summary>
 	/// Creates a new, empty <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and sets its initial capacity to specified value.
 	/// </summary>
 	/// <param name="initialCapacity">Initial capacity of the dictionary.</param>
 	public CharSpanLookupDictionary(int initialCapacity)
 	{
 		this._internalBuckets = new Dictionary<ulong, KeyedValue>(initialCapacity);
 	}
 
 	/// <summary>
 	/// Creates a new <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 	/// </summary>
 	/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 	public CharSpanLookupDictionary(IDictionary<string, TValue> values)
 		: this(values.Count)
 	{
 		foreach (var (k, v) in values)
 			this.Add(k, v);
 	}
 
 	/// <summary>
 	/// Creates a new <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 	/// </summary>
 	/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 	public CharSpanLookupDictionary(IReadOnlyDictionary<string, TValue> values)
 		 : this(values.Count)
 	{
 		foreach (var (k, v) in values)
 			this.Add(k, v);
 	}
 
 	/// <summary>
 	/// Creates a new <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied key-value collection.
 	/// </summary>
 	/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 	public CharSpanLookupDictionary(IEnumerable<KeyValuePair<string, TValue>> values)
 		: this()
 	{
 		foreach (var (k, v) in values)
 			this.Add(k, v);
 	}
 
 	/// <summary>
 	/// Inserts a specific key and corresponding value into this dictionary.
 	/// </summary>
 	/// <param name="key">Key to insert.</param>
 	/// <param name="value">Value corresponding to this key.</param>
 	public void Add(string key, TValue value)
 	{
 		if (!this.TryInsertInternal(key, value, false))
 			throw new ArgumentException("Given key is already present in the dictionary.", nameof(key));
 	}
 
 	/// <summary>
 	/// Inserts a specific key and corresponding value into this dictionary.
 	/// </summary>
 	/// <param name="key">Key to insert.</param>
 	/// <param name="value">Value corresponding to this key.</param>
 	public void Add(ReadOnlySpan<char> key, TValue value)
 	{
 		unsafe
 		{
 			fixed (char* chars = &key.GetPinnableReference())
 				if (!this.TryInsertInternal(new string(chars, 0, key.Length), value, false))
 					throw new ArgumentException("Given key is already present in the dictionary.", nameof(key));
 		}
 	}
 
 	/// <summary>
 	/// Attempts to insert a specific key and corresponding value into this dictionary.
 	/// </summary>
 	/// <param name="key">Key to insert.</param>
 	/// <param name="value">Value corresponding to this key.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryAdd(string key, TValue value)
 		=> this.TryInsertInternal(key, value, false);
 
 	/// <summary>
 	/// Attempts to insert a specific key and corresponding value into this dictionary.
 	/// </summary>
 	/// <param name="key">Key to insert.</param>
 	/// <param name="value">Value corresponding to this key.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryAdd(ReadOnlySpan<char> key, TValue value)
 	{
 		unsafe
 		{
 			fixed (char* chars = &key.GetPinnableReference())
 				return this.TryInsertInternal(new string(chars, 0, key.Length), value, false);
 		}
 	}
 
 	/// <summary>
 	/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 	/// </summary>
 	/// <param name="key">Key to retrieve the value for.</param>
 	/// <param name="value">Retrieved value.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryGetValue(string key, out TValue value)
 	{
 		if (key == null)
 			throw new ArgumentNullException(nameof(key));
 
 		return this.TryRetrieveInternal(key.AsSpan(), out value);
 	}
 
 	/// <summary>
 	/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 	/// </summary>
 	/// <param name="key">Key to retrieve the value for.</param>
 	/// <param name="value">Retrieved value.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryGetValue(ReadOnlySpan<char> key, out TValue value)
 		=> this.TryRetrieveInternal(key, out value);
 
 	/// <summary>
 	/// Attempts to remove a value corresponding to the supplied key from this dictionary.
 	/// </summary>
 	/// <param name="key">Key to remove the value for.</param>
 	/// <param name="value">Removed value.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryRemove(string key, out TValue value)
 	{
 		if (key == null)
 			throw new ArgumentNullException(nameof(key));
 
 		return this.TryRemoveInternal(key.AsSpan(), out value);
 	}
 
 	/// <summary>
 	/// Attempts to remove a value corresponding to the supplied key from this dictionary.
 	/// </summary>
 	/// <param name="key">Key to remove the value for.</param>
 	/// <param name="value">Removed value.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryRemove(ReadOnlySpan<char> key, out TValue value)
 		=> this.TryRemoveInternal(key, out value);
 
 	/// <summary>
 	/// Checks whether this dictionary contains the specified key.
 	/// </summary>
 	/// <param name="key">Key to check for in this dictionary.</param>
 	/// <returns>Whether the key was present in the dictionary.</returns>
 	public bool ContainsKey(string key)
 		=> this.ContainsKeyInternal(key.AsSpan());
 
 	/// <summary>
 	/// Checks whether this dictionary contains the specified key.
 	/// </summary>
 	/// <param name="key">Key to check for in this dictionary.</param>
 	/// <returns>Whether the key was present in the dictionary.</returns>
 	public bool ContainsKey(ReadOnlySpan<char> key)
 		=> this.ContainsKeyInternal(key);
 
 	/// <summary>
 	/// Removes all items from this dictionary.
 	/// </summary>
 	public void Clear()
 	{
 		this._internalBuckets.Clear();
 		this.Count = 0;
 	}
 
 	/// <summary>
 	/// Gets an enumerator over key-value pairs in this dictionary.
 	/// </summary>
 	/// <returns></returns>
 	public IEnumerator<KeyValuePair<string, TValue>> GetEnumerator()
 		=> new Enumerator(this);
 
 	/// <summary>
 	/// Removes the.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <returns>A bool.</returns>
 	bool IDictionary<string, TValue>.Remove(string key)
 		=> this.TryRemove(key.AsSpan(), out _);
 
 	/// <summary>
 	/// Adds the.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	void IDictionary.Add(object key, object value)
 	{
 		if (!(key is string tkey))
 			throw new ArgumentException("Key needs to be an instance of a string.");
 
 		if (!(value is TValue tvalue))
 		{
 			tvalue = default;
 			if (tvalue != null)
 				throw new ArgumentException($"Value needs to be an instance of {typeof(TValue)}.");
 		}
 
 		this.Add(tkey, tvalue);
 	}
 
 	/// <summary>
 	/// Removes the.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	void IDictionary.Remove(object key)
 	{
 		if (!(key is string tkey))
 			throw new ArgumentException("Key needs to be an instance of a string.");
 
 		this.TryRemove(tkey, out _);
 	}
 
 	/// <summary>
 	/// Contains the.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <returns>A bool.</returns>
 	bool IDictionary.Contains(object key)
 	{
 		if (!(key is string tkey))
 			throw new ArgumentException("Key needs to be an instance of a string.");
 
 		return this.ContainsKey(tkey);
 	}
 
 	/// <summary>
 	/// Gets the enumerator.
 	/// </summary>
 	/// <returns>An IDictionaryEnumerator.</returns>
 	IDictionaryEnumerator IDictionary.GetEnumerator()
 		=> new Enumerator(this);
 
 	/// <summary>
 	/// Adds the.
 	/// </summary>
 	/// <param name="item">The item.</param>
 	void ICollection<KeyValuePair<string, TValue>>.Add(KeyValuePair<string, TValue> item)
 		=> this.Add(item.Key, item.Value);
 
 	/// <summary>
 	/// Removes the.
 	/// </summary>
 	/// <param name="item">The item.</param>
 	/// <returns>A bool.</returns>
 	bool ICollection<KeyValuePair<string, TValue>>.Remove(KeyValuePair<string, TValue> item)
 		=> this.TryRemove(item.Key, out _);
 
 	/// <summary>
 	/// Contains the.
 	/// </summary>
 	/// <param name="item">The item.</param>
 	/// <returns>A bool.</returns>
 	bool ICollection<KeyValuePair<string, TValue>>.Contains(KeyValuePair<string, TValue> item)
 		=> this.TryGetValue(item.Key, out var value) && EqualityComparer<TValue>.Default.Equals(value, item.Value);
 
 	/// <summary>
 	/// Copies the to.
 	/// </summary>
 	/// <param name="array">The array.</param>
 	/// <param name="arrayIndex">The array index.</param>
 	void ICollection<KeyValuePair<string, TValue>>.CopyTo(KeyValuePair<string, TValue>[] array, int arrayIndex)
 	{
 		if (array.Length - arrayIndex < this.Count)
 			throw new ArgumentException("Target array is too small.", nameof(array));
 
 		var i = arrayIndex;
 		foreach (var (k, v) in this._internalBuckets)
 		{
 			var kdv = v;
 			while (kdv != null)
 			{
 				array[i++] = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 				kdv = kdv.Next;
 			}
 		}
 	}
 
 	/// <summary>
 	/// Copies the to.
 	/// </summary>
 	/// <param name="array">The array.</param>
 	/// <param name="arrayIndex">The array index.</param>
 	void ICollection.CopyTo(Array array, int arrayIndex)
 	{
 		if (array is KeyValuePair<string, TValue>[] tarray)
 		{
 			(this as ICollection<KeyValuePair<string, TValue>>).CopyTo(tarray, arrayIndex);
 			return;
 		}
 
 		if (array is not object[])
 			throw new ArgumentException($"Array needs to be an instance of {typeof(TValue[])} or object[].");
 
 		var i = arrayIndex;
 		foreach (var (k, v) in this._internalBuckets)
 		{
 			var kdv = v;
 			while (kdv != null)
 			{
 				array.SetValue(new KeyValuePair<string, TValue>(kdv.Key, kdv.Value), i++);
 				kdv = kdv.Next;
 			}
 		}
 	}
 
 	/// <summary>
 	/// Gets the enumerator.
 	/// </summary>
 	/// <returns>An IEnumerator.</returns>
 	IEnumerator IEnumerable.GetEnumerator()
 		=> this.GetEnumerator();
 
 	/// <summary>
 	/// Tries the insert internal.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	/// <param name="replace">If true, replace.</param>
 	/// <returns>A bool.</returns>
 	private bool TryInsertInternal(string key, TValue value, bool replace)
 	{
 		if (key == null)
 			throw new ArgumentNullException(nameof(key), "Key cannot be null.");
 
 		var hash = key.CalculateKnuthHash();
 		if (!this._internalBuckets.ContainsKey(hash))
 		{
 			this._internalBuckets.Add(hash, new KeyedValue(key, hash, value));
 			this.Count++;
 			return true;
 		}
 
 		var kdv = this._internalBuckets[hash];
 		var kdvLast = kdv;
 		while (kdv != null)
 		{
 			if (kdv.Key == key)
 			{
 				if (!replace)
 					return false;
 
 				kdv.Value = value;
 				return true;
 			}
 
 			kdvLast = kdv;
 			kdv = kdv.Next;
 		}
 
 		kdvLast.Next = new KeyedValue(key, hash, value);
 		this.Count++;
 		return true;
 	}
 
 	/// <summary>
 	/// Tries the retrieve internal.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	/// <returns>A bool.</returns>
 	private bool TryRetrieveInternal(ReadOnlySpan<char> key, out TValue value)
 	{
 		value = default;
 
 		var hash = key.CalculateKnuthHash();
 		if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 			return false;
 
 		while (kdv != null)
 		{
 			if (key.SequenceEqual(kdv.Key.AsSpan()))
 			{
 				value = kdv.Value;
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Tries the remove internal.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	/// <returns>A bool.</returns>
 	private bool TryRemoveInternal(ReadOnlySpan<char> key, out TValue value)
 	{
 		value = default;
 
 		var hash = key.CalculateKnuthHash();
 		if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 			return false;
 
 		if (kdv.Next == null && key.SequenceEqual(kdv.Key.AsSpan()))
 		{
 			// Only bucket under this hash and key matches, pop the entire bucket
 
 			value = kdv.Value;
 			this._internalBuckets.Remove(hash);
 			this.Count--;
 			return true;
 		}
 		else if (kdv.Next == null)
 		{
 			// Only bucket under this hash and key does not match, cannot remove
 
 			return false;
 		}
 		else if (key.SequenceEqual(kdv.Key.AsSpan()))
 		{
 			// First key in the bucket matches, pop it and set its child as current bucket
 
 			value = kdv.Value;
 			this._internalBuckets[hash] = kdv.Next;
 			this.Count--;
 			return true;
 		}
 
 		var kdvLast = kdv;
 		kdv = kdv.Next;
 		while (kdv != null)
 		{
 			if (key.SequenceEqual(kdv.Key.AsSpan()))
 			{
 				// Key matched, remove this bucket from the chain
 
 				value = kdv.Value;
 				kdvLast.Next = kdv.Next;
 				this.Count--;
 				return true;
 			}
 
 			kdvLast = kdv;
 			kdv = kdv.Next;
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Contains the key internal.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <returns>A bool.</returns>
 	private bool ContainsKeyInternal(ReadOnlySpan<char> key)
 	{
 		var hash = key.CalculateKnuthHash();
 		if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 			return false;
 
 		while (kdv != null)
 		{
 			if (key.SequenceEqual(kdv.Key.AsSpan()))
 				return true;
 
 			kdv = kdv.Next;
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Gets the keys internal.
 	/// </summary>
 	/// <returns>An ImmutableArray.</returns>
 	private ImmutableArray<string> GetKeysInternal()
 	{
 		var builder = ImmutableArray.CreateBuilder<string>(this.Count);
 		foreach (var value in this._internalBuckets.Values)
 		{
 			var kdv = value;
 			while (kdv != null)
 			{
 				builder.Add(kdv.Key);
 				kdv = kdv.Next;
 			}
 		}
 
 		return builder.MoveToImmutable();
 	}
 
 	/// <summary>
 	/// Gets the values internal.
 	/// </summary>
 	/// <returns>An ImmutableArray.</returns>
 	private ImmutableArray<TValue> GetValuesInternal()
 	{
 		var builder = ImmutableArray.CreateBuilder<TValue>(this.Count);
 		foreach (var value in this._internalBuckets.Values)
 		{
 			var kdv = value;
 			while (kdv != null)
 			{
 				builder.Add(kdv.Value);
 				kdv = kdv.Next;
 			}
 		}
 
 		return builder.MoveToImmutable();
 	}
 
 	/// <summary>
 	/// The keyed value.
 	/// </summary>
 	private class KeyedValue
 	{
 		/// <summary>
 		/// Gets the key hash.
 		/// </summary>
 		public ulong KeyHash { get; }
 		/// <summary>
 		/// Gets the key.
 		/// </summary>
 		public string Key { get; }
 		/// <summary>
 		/// Gets or sets the value.
 		/// </summary>
 		public TValue Value { get; set; }
 
 		/// <summary>
 		/// Gets or sets the next.
 		/// </summary>
 		public KeyedValue Next { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="KeyedValue"/> class.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="keyHash">The key hash.</param>
 		/// <param name="value">The value.</param>
 		public KeyedValue(string key, ulong keyHash, TValue value)
 		{
 			this.KeyHash = keyHash;
 			this.Key = key;
 			this.Value = value;
 		}
 	}
 
 	/// <summary>
 	/// The enumerator.
 	/// </summary>
 	private class Enumerator :
 		IEnumerator<KeyValuePair<string, TValue>>,
 		IDictionaryEnumerator
 	{
 		/// <summary>
 		/// Gets the current.
 		/// </summary>
 		public KeyValuePair<string, TValue> Current { get; private set; }
 		/// <summary>
 		/// Gets the current.
 		/// </summary>
 		object IEnumerator.Current => this.Current;
 		/// <summary>
 		/// Gets the key.
 		/// </summary>
 		object IDictionaryEnumerator.Key => this.Current.Key;
 		/// <summary>
 		/// Gets the value.
 		/// </summary>
 		object IDictionaryEnumerator.Value => this.Current.Value;
 		/// <summary>
 		/// Gets the entry.
 		/// </summary>
 		DictionaryEntry IDictionaryEnumerator.Entry => new(this.Current.Key, this.Current.Value);
 
 		/// <summary>
 		/// Gets the internal dictionary.
 		/// </summary>
 		private readonly CharSpanLookupDictionary<TValue> _internalDictionary;
 
 		/// <summary>
 		/// Gets the internal enumerator.
 		/// </summary>
 		private readonly IEnumerator<KeyValuePair<ulong, KeyedValue>> _internalEnumerator;
 
 		/// <summary>
 		/// Gets or sets the current value.
 		/// </summary>
 		private KeyedValue _currentValue;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Enumerator"/> class.
 		/// </summary>
 		/// <param name="spDict">The sp dict.</param>
 		public Enumerator(CharSpanLookupDictionary<TValue> spDict)
 		{
 			this._internalDictionary = spDict;
 			this._internalEnumerator = this._internalDictionary._internalBuckets.GetEnumerator();
 		}
 
 		/// <summary>
 		/// Moves the next.
 		/// </summary>
 		/// <returns>A bool.</returns>
 		public bool MoveNext()
 		{
 			var kdv = this._currentValue;
 			if (kdv == null)
 			{
 				if (!this._internalEnumerator.MoveNext())
 					return false;
 
 				kdv = this._internalEnumerator.Current.Value;
 				this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 
 				this._currentValue = kdv.Next;
 				return true;
 			}
 
 			this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 			this._currentValue = kdv.Next;
 			return true;
 		}
 
 		/// <summary>
 		/// Resets the.
 		/// </summary>
 		public void Reset()
 		{
 			this._internalEnumerator.Reset();
 			this.Current = default;
 			this._currentValue = null;
 		}
 
 		/// <summary>
 		/// Disposes the.
 		/// </summary>
 		public void Dispose() => this.Reset();
 	}
 }
diff --git a/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs b/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs
index b8c3b2a1d..e10dd97ff 100644
--- a/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs
+++ b/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs
@@ -1,415 +1,415 @@
 // 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;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
 
 namespace DisCatSharp.Common;
 
 /// <summary>
-/// Represents collection of string keys and <typeparamref name="TValue"/> values, allowing the use of <see cref="System.ReadOnlySpan{T}"/> for dictionary operations.
+/// Represents collection of string keys and <typeparamref name="TValue"/> values, allowing the use of <see cref="ReadOnlySpan{T}"/> for dictionary operations.
 /// </summary>
 /// <typeparam name="TValue">Type of items in this dictionary.</typeparam>
 public sealed class CharSpanLookupReadOnlyDictionary<TValue> : IReadOnlyDictionary<string, TValue>
 {
 	/// <summary>
 	/// Gets the collection of all keys present in this dictionary.
 	/// </summary>
 	public IEnumerable<string> Keys => this.GetKeysInternal();
 
 	/// <summary>
 	/// Gets the collection of all values present in this dictionary.
 	/// </summary>
 	public IEnumerable<TValue> Values => this.GetValuesInternal();
 
 	/// <summary>
 	/// Gets the total number of items in this dictionary.
 	/// </summary>
 	public int Count { get; }
 
 	/// <summary>
 	/// Gets a value corresponding to given key in this dictionary.
 	/// </summary>
 	/// <param name="key">Key to get or set the value for.</param>
 	/// <returns>Value matching the supplied key, if applicable.</returns>
 	public TValue this[string key]
 	{
 		get
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key));
 
 			if (!this.TryRetrieveInternal(key.AsSpan(), out var value))
 				throw new KeyNotFoundException($"The given key '{key}' was not present in the dictionary.");
 
 			return value;
 		}
 	}
 
 	/// <summary>
 	/// Gets a value corresponding to given key in this dictionary.
 	/// </summary>
 	/// <param name="key">Key to get or set the value for.</param>
 	/// <returns>Value matching the supplied key, if applicable.</returns>
 	public TValue this[ReadOnlySpan<char> key]
 	{
 		get
 		{
 			if (!this.TryRetrieveInternal(key, out var value))
 				throw new KeyNotFoundException($"The given key was not present in the dictionary.");
 
 			return value;
 		}
 	}
 
 	/// <summary>
 	/// Gets the internal buckets.
 	/// </summary>
 	private readonly IReadOnlyDictionary<ulong, KeyedValue> _internalBuckets;
 
 	/// <summary>
 	/// Creates a new <see cref="CharSpanLookupReadOnlyDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 	/// </summary>
 	/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 	public CharSpanLookupReadOnlyDictionary(IDictionary<string, TValue> values)
 		: this(values as IEnumerable<KeyValuePair<string, TValue>>)
 	{ }
 
 	/// <summary>
 	/// Creates a new <see cref="CharSpanLookupReadOnlyDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 	/// </summary>
 	/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 	public CharSpanLookupReadOnlyDictionary(IReadOnlyDictionary<string, TValue> values)
 		: this(values as IEnumerable<KeyValuePair<string, TValue>>)
 	{ }
 
 	/// <summary>
 	/// Creates a new <see cref="CharSpanLookupReadOnlyDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied key-value collection.
 	/// </summary>
 	/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 	public CharSpanLookupReadOnlyDictionary(IEnumerable<KeyValuePair<string, TValue>> values)
 	{
 		this._internalBuckets = PrepareItems(values, out var count);
 		this.Count = count;
 	}
 
 	/// <summary>
 	/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 	/// </summary>
 	/// <param name="key">Key to retrieve the value for.</param>
 	/// <param name="value">Retrieved value.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryGetValue(string key, out TValue value)
 	{
 		if (key == null)
 			throw new ArgumentNullException(nameof(key));
 
 		return this.TryRetrieveInternal(key.AsSpan(), out value);
 	}
 
 	/// <summary>
 	/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 	/// </summary>
 	/// <param name="key">Key to retrieve the value for.</param>
 	/// <param name="value">Retrieved value.</param>
 	/// <returns>Whether the operation was successful.</returns>
 	public bool TryGetValue(ReadOnlySpan<char> key, out TValue value)
 		=> this.TryRetrieveInternal(key, out value);
 
 	/// <summary>
 	/// Checks whether this dictionary contains the specified key.
 	/// </summary>
 	/// <param name="key">Key to check for in this dictionary.</param>
 	/// <returns>Whether the key was present in the dictionary.</returns>
 	public bool ContainsKey(string key)
 		=> this.ContainsKeyInternal(key.AsSpan());
 
 	/// <summary>
 	/// Checks whether this dictionary contains the specified key.
 	/// </summary>
 	/// <param name="key">Key to check for in this dictionary.</param>
 	/// <returns>Whether the key was present in the dictionary.</returns>
 	public bool ContainsKey(ReadOnlySpan<char> key)
 		=> this.ContainsKeyInternal(key);
 
 	/// <summary>
 	/// Gets an enumerator over key-value pairs in this dictionary.
 	/// </summary>
 	/// <returns></returns>
 	public IEnumerator<KeyValuePair<string, TValue>> GetEnumerator()
 		=> new Enumerator(this);
 
 	/// <summary>
 	/// Gets the enumerator.
 	/// </summary>
 	/// <returns>An IEnumerator.</returns>
 	IEnumerator IEnumerable.GetEnumerator()
 		=> this.GetEnumerator();
 
 	/// <summary>
 	/// Tries the retrieve internal.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	/// <returns>A bool.</returns>
 	private bool TryRetrieveInternal(ReadOnlySpan<char> key, out TValue value)
 	{
 		value = default;
 
 		var hash = key.CalculateKnuthHash();
 		if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 			return false;
 
 		while (kdv != null)
 		{
 			if (key.SequenceEqual(kdv.Key.AsSpan()))
 			{
 				value = kdv.Value;
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Contains the key internal.
 	/// </summary>
 	/// <param name="key">The key.</param>
 	/// <returns>A bool.</returns>
 	private bool ContainsKeyInternal(ReadOnlySpan<char> key)
 	{
 		var hash = key.CalculateKnuthHash();
 		if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 			return false;
 
 		while (kdv != null)
 		{
 			if (key.SequenceEqual(kdv.Key.AsSpan()))
 				return true;
 
 			kdv = kdv.Next;
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Gets the keys internal.
 	/// </summary>
 	/// <returns>An ImmutableArray.</returns>
 	private ImmutableArray<string> GetKeysInternal()
 	{
 		var builder = ImmutableArray.CreateBuilder<string>(this.Count);
 		foreach (var value in this._internalBuckets.Values)
 		{
 			var kdv = value;
 			while (kdv != null)
 			{
 				builder.Add(kdv.Key);
 				kdv = kdv.Next;
 			}
 		}
 
 		return builder.MoveToImmutable();
 	}
 
 	/// <summary>
 	/// Gets the values internal.
 	/// </summary>
 	/// <returns>An ImmutableArray.</returns>
 	private ImmutableArray<TValue> GetValuesInternal()
 	{
 		var builder = ImmutableArray.CreateBuilder<TValue>(this.Count);
 		foreach (var value in this._internalBuckets.Values)
 		{
 			var kdv = value;
 			while (kdv != null)
 			{
 				builder.Add(kdv.Value);
 				kdv = kdv.Next;
 			}
 		}
 
 		return builder.MoveToImmutable();
 	}
 
 	/// <summary>
 	/// Prepares the items.
 	/// </summary>
 	/// <param name="items">The items.</param>
 	/// <param name="count">The count.</param>
 	/// <returns>An IReadOnlyDictionary.</returns>
 	private static IReadOnlyDictionary<ulong, KeyedValue> PrepareItems(IEnumerable<KeyValuePair<string, TValue>> items, out int count)
 	{
 		count = 0;
 		var dict = new Dictionary<ulong, KeyedValue>();
 		foreach (var (k, v) in items)
 		{
 			if (k == null)
 				throw new ArgumentException("Keys cannot be null.", nameof(items));
 
 			var hash = k.CalculateKnuthHash();
 			if (!dict.ContainsKey(hash))
 			{
 				dict.Add(hash, new KeyedValue(k, hash, v));
 				count++;
 				continue;
 			}
 
 			var kdv = dict[hash];
 			var kdvLast = kdv;
 			while (kdv != null)
 			{
 				if (kdv.Key == k)
 					throw new ArgumentException("Given key is already present in the dictionary.", nameof(items));
 
 				kdvLast = kdv;
 				kdv = kdv.Next;
 			}
 
 			kdvLast.Next = new KeyedValue(k, hash, v);
 			count++;
 		}
 
 		return new ReadOnlyDictionary<ulong, KeyedValue>(dict);
 	}
 
 	/// <summary>
 	/// The keyed value.
 	/// </summary>
 	private class KeyedValue
 	{
 		/// <summary>
 		/// Gets the key hash.
 		/// </summary>
 		public ulong KeyHash { get; }
 		/// <summary>
 		/// Gets the key.
 		/// </summary>
 		public string Key { get; }
 		/// <summary>
 		/// Gets or sets the value.
 		/// </summary>
 		public TValue Value { get; set; }
 
 		/// <summary>
 		/// Gets or sets the next.
 		/// </summary>
 		public KeyedValue Next { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="KeyedValue"/> class.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="keyHash">The key hash.</param>
 		/// <param name="value">The value.</param>
 		public KeyedValue(string key, ulong keyHash, TValue value)
 		{
 			this.KeyHash = keyHash;
 			this.Key = key;
 			this.Value = value;
 		}
 	}
 
 	/// <summary>
 	/// The enumerator.
 	/// </summary>
 	private class Enumerator : IEnumerator<KeyValuePair<string, TValue>>
 	{
 		/// <summary>
 		/// Gets the current.
 		/// </summary>
 		public KeyValuePair<string, TValue> Current { get; private set; }
 		/// <summary>
 		/// Gets the current.
 		/// </summary>
 		object IEnumerator.Current => this.Current;
 
 		/// <summary>
 		/// Gets the internal dictionary.
 		/// </summary>
 		private readonly CharSpanLookupReadOnlyDictionary<TValue> _internalDictionary;
 
 		/// <summary>
 		/// Gets the internal enumerator.
 		/// </summary>
 		private readonly IEnumerator<KeyValuePair<ulong, KeyedValue>> _internalEnumerator;
 
 		/// <summary>
 		/// Gets or sets the current value.
 		/// </summary>
 		private KeyedValue _currentValue;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Enumerator"/> class.
 		/// </summary>
 		/// <param name="spDict">The sp dict.</param>
 		public Enumerator(CharSpanLookupReadOnlyDictionary<TValue> spDict)
 		{
 			this._internalDictionary = spDict;
 			this._internalEnumerator = this._internalDictionary._internalBuckets.GetEnumerator();
 		}
 
 		/// <summary>
 		/// Moves the next.
 		/// </summary>
 		/// <returns>A bool.</returns>
 		public bool MoveNext()
 		{
 			var kdv = this._currentValue;
 			if (kdv == null)
 			{
 				if (!this._internalEnumerator.MoveNext())
 					return false;
 
 				kdv = this._internalEnumerator.Current.Value;
 				this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 
 				this._currentValue = kdv.Next;
 				return true;
 			}
 
 			this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 			this._currentValue = kdv.Next;
 			return true;
 		}
 
 		/// <summary>
 		/// Resets the.
 		/// </summary>
 		public void Reset()
 		{
 			this._internalEnumerator.Reset();
 			this.Current = default;
 			this._currentValue = null;
 		}
 
 		/// <summary>
 		/// Disposes the.
 		/// </summary>
 		public void Dispose() => this.Reset();
 	}
 }
diff --git a/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs b/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs
index 0368bb08d..95937b8fb 100644
--- a/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs
+++ b/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs
@@ -1,254 +1,254 @@
 // 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.Buffers;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace DisCatSharp.Common.Types;
 
 /// <summary>
 /// Provides a resizable memory buffer analogous to <see cref="MemoryBuffer{T}"/>, using a single continuous memory region instead.
 /// </summary>
 /// <typeparam name="T">Type of item to hold in the buffer.</typeparam>
 public sealed class ContinuousMemoryBuffer<T> : IMemoryBuffer<T> where T : unmanaged
 {
 	/// <inheritdoc />
 	public ulong Capacity => (ulong)this._buff.Length;
 
 	/// <inheritdoc />
 	public ulong Length => (ulong)this._pos;
 
 	/// <inheritdoc />
 	public ulong Count => (ulong)(this._pos / this._itemSize);
 
 	private readonly MemoryPool<byte> _pool;
 	private IMemoryOwner<byte> _buffOwner;
 	private Memory<byte> _buff;
 	private readonly bool _clear;
 	private int _pos;
 	private readonly int _itemSize;
 	private bool _isDisposed;
 
 	/// <summary>
 	/// Creates a new buffer with a specified segment size, specified number of initially-allocated segments, and supplied memory pool.
 	/// </summary>
 	/// <param name="initialSize">Initial size of the buffer in bytes. Defaults to 64KiB.</param>
-	/// <param name="memPool">Memory pool to use for renting buffers. Defaults to <see cref="System.Buffers.MemoryPool{T}.Shared"/>.</param>
+	/// <param name="memPool">Memory pool to use for renting buffers. Defaults to <see cref="MemoryPool{T}.Shared"/>.</param>
 	/// <param name="clearOnDispose">Determines whether the underlying buffers should be cleared on exit. If dealing with sensitive data, it might be a good idea to set this option to true.</param>
 	public ContinuousMemoryBuffer(int initialSize = 65536, MemoryPool<byte> memPool = default, bool clearOnDispose = false)
 	{
 		this._itemSize = Unsafe.SizeOf<T>();
 		this._pool = memPool ?? MemoryPool<byte>.Shared;
 		this._clear = clearOnDispose;
 
 		this._buffOwner = this._pool.Rent(initialSize);
 		this._buff = this._buffOwner.Memory;
 
 		this._isDisposed = false;
 	}
 
 	/// <inheritdoc />
 	public void Write(ReadOnlySpan<T> data)
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		var bytes = MemoryMarshal.AsBytes(data);
 		this.EnsureSize(this._pos + bytes.Length);
 
 		bytes.CopyTo(this._buff[this._pos..].Span);
 		this._pos += bytes.Length;
 	}
 
 	/// <inheritdoc />
 	public void Write(T[] data, int start, int count)
 		=> this.Write(data.AsSpan(start, count));
 
 	/// <inheritdoc />
 	public void Write(ArraySegment<T> data)
 		=> this.Write(data.AsSpan());
 
 	/// <inheritdoc />
 	public void Write(Stream stream)
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		if (stream.CanSeek)
 			this.WriteStreamSeekable(stream);
 		else
 			this.WriteStreamUnseekable(stream);
 	}
 
 	/// <summary>
 	/// Writes the stream seekable.
 	/// </summary>
 	/// <param name="stream">The stream.</param>
 	private void WriteStreamSeekable(Stream stream)
 	{
 		if (stream.Length > int.MaxValue)
 			throw new ArgumentException("Stream is too long.", nameof(stream));
 
 		this.EnsureSize(this._pos + (int)stream.Length);
 		var memo = ArrayPool<byte>.Shared.Rent((int)stream.Length);
 		try
 		{
 			var br = stream.Read(memo, 0, memo.Length);
 			memo.AsSpan(0, br).CopyTo(this._buff[this._pos..].Span);
 		}
 		finally
 		{
 			ArrayPool<byte>.Shared.Return(memo);
 		}
 
 		this._pos += (int)stream.Length;
 	}
 
 	/// <summary>
 	/// Writes the stream unseekable.
 	/// </summary>
 	/// <param name="stream">The stream.</param>
 	private void WriteStreamUnseekable(Stream stream)
 	{
 		var memo = ArrayPool<byte>.Shared.Rent(4096);
 		try
 		{
 			var br = 0;
 			while ((br = stream.Read(memo, 0, memo.Length)) != 0)
 			{
 				this.EnsureSize(this._pos + br);
 				memo.AsSpan(0, br).CopyTo(this._buff[this._pos..].Span);
 				this._pos += br;
 			}
 		}
 		finally
 		{
 			ArrayPool<byte>.Shared.Return(memo);
 		}
 	}
 
 	/// <inheritdoc />
 	public bool Read(Span<T> destination, ulong source, out int itemsWritten)
 	{
 		itemsWritten = 0;
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		source *= (ulong)this._itemSize;
 		if (source > this.Count)
 			throw new ArgumentOutOfRangeException(nameof(source), "Cannot copy data from beyond the buffer.");
 
 		var start = (int)source;
 		var sbuff = this._buff[start..this._pos ].Span;
 		var dbuff = MemoryMarshal.AsBytes(destination);
 		if (sbuff.Length > dbuff.Length)
 			sbuff = sbuff[..dbuff.Length];
 
 		itemsWritten = sbuff.Length / this._itemSize;
 		sbuff.CopyTo(dbuff);
 
 		return this.Length - source != (ulong)itemsWritten;
 	}
 
 	/// <inheritdoc />
 	public bool Read(T[] data, int start, int count, ulong source, out int itemsWritten)
 		=> this.Read(data.AsSpan(start, count), source, out itemsWritten);
 
 	/// <inheritdoc />
 	public bool Read(ArraySegment<T> data, ulong source, out int itemsWritten)
 		=> this.Read(data.AsSpan(), source, out itemsWritten);
 
 	/// <inheritdoc />
 	public T[] ToArray()
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		return MemoryMarshal.Cast<byte, T>(this._buff[..this._pos].Span).ToArray();
 	}
 
 	/// <inheritdoc />
 	public void CopyTo(Stream destination)
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		var buff = this._buff[..this._pos].ToArray();
 		destination.Write(buff, 0, buff.Length);
 	}
 
 	/// <inheritdoc />
 	public void Clear()
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		this._pos = 0;
 	}
 
 	/// <summary>
 	/// Disposes of any resources claimed by this buffer.
 	/// </summary>
 	public void Dispose()
 	{
 		if (this._isDisposed)
 			return;
 
 		this._isDisposed = true;
 		if (this._clear)
 			this._buff.Span.Clear();
 
 		this._buffOwner.Dispose();
 		this._buff = default;
 	}
 
 	/// <summary>
 	/// Ensures the size.
 	/// </summary>
 	/// <param name="newCapacity">The new capacity.</param>
 	private void EnsureSize(int newCapacity)
 	{
 		var cap = this._buff.Length;
 		if (cap >= newCapacity)
 			return;
 
 		var factor = newCapacity / cap;
 		if (newCapacity % cap != 0)
 			++factor;
 
 		var newActualCapacity = cap * factor;
 
 		var newBuffOwner = this._pool.Rent(newActualCapacity);
 		var newBuff = newBuffOwner.Memory;
 
 		this._buff.Span.CopyTo(newBuff.Span);
 		if (this._clear)
 			this._buff.Span.Clear();
 
 		this._buffOwner.Dispose();
 		this._buffOwner = newBuffOwner;
 		this._buff = newBuff;
 	}
 }
diff --git a/DisCatSharp.Common/Types/MemoryBuffer.cs b/DisCatSharp.Common/Types/MemoryBuffer.cs
index bc90b25aa..fd91cdd1f 100644
--- a/DisCatSharp.Common/Types/MemoryBuffer.cs
+++ b/DisCatSharp.Common/Types/MemoryBuffer.cs
@@ -1,339 +1,339 @@
 // 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.Buffers;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace DisCatSharp.Common.Types;
 
 /// <summary>
 /// Provides a resizable memory buffer, which can be read from and written to. It will automatically resize whenever required.
 /// </summary>
 /// <typeparam name="T">Type of item to hold in the buffer.</typeparam>
 public sealed class MemoryBuffer<T> : IMemoryBuffer<T> where T : unmanaged
 {
 	/// <inheritdoc />
 	public ulong Capacity => this._segments.Aggregate(0UL, (a, x) => a + (ulong)x.Memory.Length); // .Sum() does only int
 
 	/// <inheritdoc />
 	public ulong Length { get; private set; }
 
 	/// <inheritdoc />
 	public ulong Count => this.Length / (ulong)this._itemSize;
 
 	private readonly MemoryPool<byte> _pool;
 	private readonly int _segmentSize;
 	private int _lastSegmentLength;
 	private int _segNo;
 	private readonly bool _clear;
 	private readonly List<IMemoryOwner<byte>> _segments;
 	private readonly int _itemSize;
 	private bool _isDisposed;
 
 	/// <summary>
 	/// Creates a new buffer with a specified segment size, specified number of initially-allocated segments, and supplied memory pool.
 	/// </summary>
 	/// <param name="segmentSize">Byte size of an individual segment. Defaults to 64KiB.</param>
 	/// <param name="initialSegmentCount">Number of segments to allocate. Defaults to 0.</param>
-	/// <param name="memPool">Memory pool to use for renting buffers. Defaults to <see cref="System.Buffers.MemoryPool{T}.Shared"/>.</param>
+	/// <param name="memPool">Memory pool to use for renting buffers. Defaults to <see cref="MemoryPool{T}.Shared"/>.</param>
 	/// <param name="clearOnDispose">Determines whether the underlying buffers should be cleared on exit. If dealing with sensitive data, it might be a good idea to set this option to true.</param>
 	public MemoryBuffer(int segmentSize = 65536, int initialSegmentCount = 0, MemoryPool<byte> memPool = default, bool clearOnDispose = false)
 	{
 		this._itemSize = Unsafe.SizeOf<T>();
 		if (segmentSize % this._itemSize != 0)
 			throw new ArgumentException("Segment size must match size of individual item.");
 
 		this._pool = memPool ?? MemoryPool<byte>.Shared;
 
 		this._segmentSize = segmentSize;
 		this._segNo = 0;
 		this._lastSegmentLength = 0;
 		this._clear = clearOnDispose;
 
 		this._segments = Enumerable.Range(0, initialSegmentCount)
 			.Select(x => this._pool.Rent(this._segmentSize))
 			.ToList();
 
 		this.Length = 0;
 
 		this._isDisposed = false;
 	}
 
 	/// <inheritdoc />
 	public void Write(ReadOnlySpan<T> data)
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		var src = MemoryMarshal.AsBytes(data);
 		this.Grow(src.Length);
 
 		while (this._segNo < this._segments.Count && src.Length > 0)
 		{
 			var seg = this._segments[this._segNo];
 			var mem = seg.Memory;
 			var avs = mem.Length - this._lastSegmentLength;
 			avs = avs > src.Length
 				? src.Length
 				: avs;
 			var dmem = mem[this._lastSegmentLength..];
 
 			src[..avs].CopyTo(dmem.Span);
 			src = src[avs..];
 
 			this.Length += (ulong)avs;
 			this._lastSegmentLength += avs;
 
 			if (this._lastSegmentLength == mem.Length)
 			{
 				this._segNo++;
 				this._lastSegmentLength = 0;
 			}
 		}
 	}
 
 	/// <inheritdoc />
 	public void Write(T[] data, int start, int count)
 		=> this.Write(data.AsSpan(start, count));
 
 	/// <inheritdoc />
 	public void Write(ArraySegment<T> data)
 		=> this.Write(data.AsSpan());
 
 	/// <inheritdoc />
 	public void Write(Stream stream)
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		if (stream.CanSeek)
 			this.WriteStreamSeekable(stream);
 		else
 			this.WriteStreamUnseekable(stream);
 	}
 
 	/// <summary>
 	/// Writes the stream seekable.
 	/// </summary>
 	/// <param name="stream">The stream.</param>
 	private void WriteStreamSeekable(Stream stream)
 	{
 		var len = (int)(stream.Length - stream.Position);
 		this.Grow(len);
 
 		var buff = new byte[this._segmentSize];
 
 		while (this._segNo < this._segments.Count && len > 0)
 		{
 			var seg = this._segments[this._segNo];
 			var mem = seg.Memory;
 			var avs = mem.Length - this._lastSegmentLength;
 			avs = avs > len
 				? len
 				: avs;
 			var dmem = mem[this._lastSegmentLength..];
 
 			var lsl = this._lastSegmentLength;
 			var slen = dmem.Span.Length - lsl;
 			stream.Read(buff, 0, slen);
 			buff.AsSpan(0, slen).CopyTo(dmem.Span);
 			len -= dmem.Span.Length;
 
 			this.Length += (ulong)avs;
 			this._lastSegmentLength += avs;
 
 			if (this._lastSegmentLength == mem.Length)
 			{
 				this._segNo++;
 				this._lastSegmentLength = 0;
 			}
 		}
 	}
 
 	/// <summary>
 	/// Writes the stream unseekable.
 	/// </summary>
 	/// <param name="stream">The stream.</param>
 	private void WriteStreamUnseekable(Stream stream)
 	{
 		var read = 0;
 		var buff = new byte[this._segmentSize];
 		var buffs = buff.AsSpan();
 		while ((read = stream.Read(buff, 0, buff.Length - this._lastSegmentLength)) != 0)
 			this.Write(MemoryMarshal.Cast<byte, T>(buffs[..read]));
 	}
 
 	/// <inheritdoc />
 	public bool Read(Span<T> destination, ulong source, out int itemsWritten)
 	{
 		itemsWritten = 0;
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		source *= (ulong)this._itemSize;
 		if (source > this.Count)
 			throw new ArgumentOutOfRangeException(nameof(source), "Cannot copy data from beyond the buffer.");
 
 		// Find where to begin
 		var i = 0;
 		for (; i < this._segments.Count; i++)
 		{
 			var seg = this._segments[i];
 			var mem = seg.Memory;
 			if ((ulong)mem.Length > source)
 				break;
 
 			source -= (ulong)mem.Length;
 		}
 
 		// Do actual copy
 		var dl = (int)(this.Length - source);
 		var sri = (int)source;
 		var dst = MemoryMarshal.AsBytes(destination);
 		for (; i < this._segments.Count && dst.Length > 0; i++)
 		{
 			var seg = this._segments[i];
 			var mem = seg.Memory;
 			var src = mem.Span;
 
 			if (sri != 0)
 			{
 				src = src[sri..];
 				sri = 0;
 			}
 
 			if (itemsWritten + src.Length > dl)
 				src = src[..(dl - itemsWritten)];
 
 			if (src.Length > dst.Length)
 				src = src[..dst.Length];
 
 			src.CopyTo(dst);
 			dst = dst[src.Length..];
 			itemsWritten += src.Length;
 		}
 
 		itemsWritten /= this._itemSize;
 		return this.Length - source != (ulong)itemsWritten;
 	}
 
 	/// <inheritdoc />
 	public bool Read(T[] data, int start, int count, ulong source, out int itemsWritten)
 		=> this.Read(data.AsSpan(start, count), source, out itemsWritten);
 
 	/// <inheritdoc />
 	public bool Read(ArraySegment<T> data, ulong source, out int itemsWritten)
 		=> this.Read(data.AsSpan(), source, out itemsWritten);
 
 	/// <inheritdoc />
 	public T[] ToArray()
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		var bytes = new T[this.Count];
 		this.Read(bytes, 0, out _);
 		return bytes;
 	}
 
 	/// <inheritdoc />
 	public void CopyTo(Stream destination)
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		var longest = this._segments.Max(x => x.Memory.Length);
 		var buff = new byte[longest];
 
 		foreach (var seg in this._segments)
 		{
 			var mem = seg.Memory.Span;
 			var spn = buff.AsSpan(0, mem.Length);
 
 			mem.CopyTo(spn);
 			destination.Write(buff, 0, spn.Length);
 		}
 	}
 
 	/// <inheritdoc />
 	public void Clear()
 	{
 		if (this._isDisposed)
 			throw new ObjectDisposedException("This buffer is disposed.");
 
 		this._segNo = 0;
 		this._lastSegmentLength = 0;
 		this.Length = 0;
 	}
 
 	/// <summary>
 	/// Disposes of any resources claimed by this buffer.
 	/// </summary>
 	public void Dispose()
 	{
 		if (this._isDisposed)
 			return;
 
 		this._isDisposed = true;
 		foreach (var segment in this._segments)
 		{
 			if (this._clear)
 				segment.Memory.Span.Clear();
 
 			segment.Dispose();
 		}
 	}
 
 	/// <summary>
 	/// Grows the.
 	/// </summary>
 	/// <param name="minAmount">The min amount.</param>
 	private void Grow(int minAmount)
 	{
 		var capacity = this.Capacity;
 		var length = this.Length;
 		var totalAmt = length + (ulong)minAmount;
 		if (capacity >= totalAmt)
 			return; // we're good
 
 		var amt = (int)(totalAmt - capacity);
 		var segCount = amt / this._segmentSize;
 		if (amt % this._segmentSize != 0)
 			segCount++;
 
 		// Basically List<T>.EnsureCapacity
 		// Default grow behaviour is minimum current*2
 		var segCap = this._segments.Count + segCount;
 		if (segCap > this._segments.Capacity)
 			this._segments.Capacity = segCap < this._segments.Capacity * 2
 				? this._segments.Capacity * 2
 				: segCap;
 
 		for (var i = 0; i < segCount; i++)
 			this._segments.Add(this._pool.Rent(this._segmentSize));
 	}
 }
diff --git a/DisCatSharp.Common/Types/SecureRandom.cs b/DisCatSharp.Common/Types/SecureRandom.cs
index 917747b7c..c7a800252 100644
--- a/DisCatSharp.Common/Types/SecureRandom.cs
+++ b/DisCatSharp.Common/Types/SecureRandom.cs
@@ -1,331 +1,331 @@
 // 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.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 
 namespace DisCatSharp.Common;
 
 /// <summary>
-/// Provides a cryptographically-secure pseudorandom number generator (CSPRNG) implementation compatible with <see cref="System.Random"/>.
+/// Provides a cryptographically-secure pseudorandom number generator (CSPRNG) implementation compatible with <see cref="Random"/>.
 /// </summary>
 public sealed class SecureRandom : Random, IDisposable
 {
 	/// <summary>
 	/// Gets the r n g.
 	/// </summary>
 	private readonly RandomNumberGenerator _rng = RandomNumberGenerator.Create();
 
 	private volatile bool _isDisposed;
 
 	/// <summary>
 	/// Creates a new instance of <see cref="SecureRandom"/>.
 	/// </summary>
 	public SecureRandom()
 	{ }
 
 	/// <summary>
 	/// Finalizes this <see cref="SecureRandom"/> instance by disposing it.
 	/// </summary>
 	~SecureRandom()
 	{
 		this.Dispose();
 	}
 
 	/// <summary>
 	/// Fills a supplied buffer with random bytes.
 	/// </summary>
 	/// <param name="buffer">Buffer to fill with random bytes.</param>
 	public void GetBytes(byte[] buffer) => this._rng.GetBytes(buffer);
 
 	/// <summary>
 	/// Fills a supplied buffer with random nonzero bytes.
 	/// </summary>
 	/// <param name="buffer">Buffer to fill with random nonzero bytes.</param>
 	public void GetNonZeroBytes(byte[] buffer) => this._rng.GetNonZeroBytes(buffer);
 
 	/// <summary>
 	/// Fills a supplied memory region with random bytes.
 	/// </summary>
 	/// <param name="buffer">Memory region to fill with random bytes.</param>
 	public void GetBytes(Span<byte> buffer)
 	{
 		var buff = ArrayPool<byte>.Shared.Rent(buffer.Length);
 		try
 		{
 			var buffSpan = buff.AsSpan(0, buffer.Length);
 			this._rng.GetBytes(buff);
 			buffSpan.CopyTo(buffer);
 		}
 		finally
 		{
 			ArrayPool<byte>.Shared.Return(buff);
 		}
 	}
 
 	/// <summary>
 	/// Fills a supplied memory region with random nonzero bytes.
 	/// </summary>
 	/// <param name="buffer">Memory region to fill with random nonzero bytes.</param>
 	public void GetNonZeroBytes(Span<byte> buffer)
 	{
 		var buff = ArrayPool<byte>.Shared.Rent(buffer.Length);
 		try
 		{
 			var buffSpan = buff.AsSpan(0, buffer.Length);
 			this._rng.GetNonZeroBytes(buff);
 			buffSpan.CopyTo(buffer);
 		}
 		finally
 		{
 			ArrayPool<byte>.Shared.Return(buff);
 		}
 	}
 
 	/// <summary>
 	/// Generates a signed 8-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="sbyte.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public sbyte GetInt8(sbyte min = 0, sbyte max = sbyte.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		var offset = (sbyte)(min < 0 ? -min : 0);
 		min += offset;
 		max += offset;
 
 		return (sbyte)(Math.Abs(this.Generate<sbyte>()) % (max - min) + min - offset);
 	}
 
 	/// <summary>
 	/// Generates a unsigned 8-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="byte.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public byte GetUInt8(byte min = 0, byte max = byte.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		return (byte)(this.Generate<byte>() % (max - min) + min);
 	}
 
 	/// <summary>
 	/// Generates a signed 16-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="short.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public short GetInt16(short min = 0, short max = short.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		var offset = (short)(min < 0 ? -min : 0);
 		min += offset;
 		max += offset;
 
 		return (short)(Math.Abs(this.Generate<short>()) % (max - min) + min - offset);
 	}
 
 	/// <summary>
 	/// Generates a unsigned 16-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="ushort.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public ushort GetUInt16(ushort min = 0, ushort max = ushort.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		return (ushort)(this.Generate<ushort>() % (max - min) + min);
 	}
 
 	/// <summary>
 	/// Generates a signed 32-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="int.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public int GetInt32(int min = 0, int max = int.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		var offset = min < 0 ? -min : 0;
 		min += offset;
 		max += offset;
 
 		return Math.Abs(this.Generate<int>()) % (max - min) + min - offset;
 	}
 
 	/// <summary>
 	/// Generates a unsigned 32-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="uint.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public uint GetUInt32(uint min = 0, uint max = uint.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		return this.Generate<uint>() % (max - min) + min;
 	}
 
 	/// <summary>
 	/// Generates a signed 64-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="long.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public long GetInt64(long min = 0, long max = long.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		var offset = min < 0 ? -min : 0;
 		min += offset;
 		max += offset;
 
 		return Math.Abs(this.Generate<long>()) % (max - min) + min - offset;
 	}
 
 	/// <summary>
 	/// Generates a unsigned 64-bit integer within specified range.
 	/// </summary>
 	/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 	/// <param name="max">Maximum value to generate. Defaults to <see cref="ulong.MaxValue"/>.</param>
 	/// <returns>Generated random value.</returns>
 	public ulong GetUInt64(ulong min = 0, ulong max = ulong.MaxValue)
 	{
 		if (max <= min)
 			throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 		return this.Generate<ulong>() % (max - min) + min;
 	}
 
 	/// <summary>
 	/// Generates a 32-bit floating-point number between 0.0 and 1.0.
 	/// </summary>
 	/// <returns>Generated 32-bit floating-point number.</returns>
 	public float GetSingle()
 	{
 		var (i1, i2) = ((float)this.GetInt32(), (float)this.GetInt32());
 		return i1 / i2 % 1.0F;
 	}
 
 	/// <summary>
 	/// Generates a 64-bit floating-point number between 0.0 and 1.0.
 	/// </summary>
 	/// <returns>Generated 64-bit floating-point number.</returns>
 	public double GetDouble()
 	{
 		var (i1, i2) = ((double)this.GetInt64(), (double)this.GetInt64());
 		return i1 / i2 % 1.0;
 	}
 
 	/// <summary>
 	/// Generates a 32-bit integer between 0 and <see cref="int.MaxValue"/>. Upper end exclusive.
 	/// </summary>
 	/// <returns>Generated 32-bit integer.</returns>
 	public override int Next()
 		=> this.GetInt32();
 
 	/// <summary>
 	/// Generates a 32-bit integer between 0 and <paramref name="maxValue"/>. Upper end exclusive.
 	/// </summary>
 	/// <param name="maxValue">Maximum value of the generated integer.</param>
 	/// <returns>Generated 32-bit integer.</returns>
 	public override int Next(int maxValue)
 		=> this.GetInt32(0, maxValue);
 
 	/// <summary>
 	/// Generates a 32-bit integer between <paramref name="minValue"/> and <paramref name="maxValue"/>. Upper end exclusive.
 	/// </summary>
 	/// <param name="minValue">Minimum value of the generate integer.</param>
 	/// <param name="maxValue">Maximum value of the generated integer.</param>
 	/// <returns>Generated 32-bit integer.</returns>
 	public override int Next(int minValue, int maxValue)
 		=> this.GetInt32(minValue, maxValue);
 
 	/// <summary>
 	/// Generates a 64-bit floating-point number between 0.0 and 1.0. Upper end exclusive.
 	/// </summary>
 	/// <returns>Generated 64-bit floating-point number.</returns>
 	public override double NextDouble()
 		=> this.GetDouble();
 
 	/// <summary>
 	/// Fills specified buffer with random bytes.
 	/// </summary>
 	/// <param name="buffer">Buffer to fill with bytes.</param>
 	public override void NextBytes(byte[] buffer)
 		=> this.GetBytes(buffer);
 
 	/// <summary>
 	/// Fills specified memory region with random bytes.
 	/// </summary>
 	/// <param name="buffer">Memory region to fill with bytes.</param>
 	public new void NextBytes(Span<byte> buffer)
 		=> this.GetBytes(buffer);
 
 	/// <summary>
 	/// Disposes this <see cref="SecureRandom"/> instance and its resources.
 	/// </summary>
 	public void Dispose()
 	{
 		if (this._isDisposed)
 			return;
 
 		this._isDisposed = true;
 		this._rng.Dispose();
 		GC.SuppressFinalize(this);
 	}
 
 	/// <summary>
 	/// Generates a random 64-bit floating-point number between 0.0 and 1.0. Upper end exclusive.
 	/// </summary>
 	/// <returns>Generated 64-bit floating-point number.</returns>
 	protected override double Sample()
 		=> this.GetDouble();
 
 	/// <summary>
 	/// Generates the.
 	/// </summary>
 	/// <returns>A T.</returns>
 	private T Generate<T>() where T : struct
 	{
 		var size = Unsafe.SizeOf<T>();
 		Span<byte> buff = stackalloc byte[size];
 		this.GetBytes(buff);
 		return MemoryMarshal.Read<T>(buff);
 	}
 }
diff --git a/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs b/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs
index dc7f30976..b6c5e5e39 100644
--- a/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs
+++ b/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs
@@ -1,114 +1,114 @@
 // 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.Numerics;
 
 namespace DisCatSharp.Common.Serialization;
 
 /// <summary>
-/// Decomposes <see cref="System.Numerics.Complex"/> numbers into tuples (arrays of 2).
+/// Decomposes <see cref="Complex"/> numbers into tuples (arrays of 2).
 /// </summary>
 public sealed class ComplexDecomposer : IDecomposer
 {
 	/// <summary>
 	/// Gets the t complex.
 	/// </summary>
 	private static Type s_complex { get; } = typeof(Complex);
 	/// <summary>
 	/// Gets the t double array.
 	/// </summary>
 	private static Type s_doubleArray { get; } = typeof(double[]);
 	/// <summary>
 	/// Gets the t double enumerable.
 	/// </summary>
 	private static Type s_doubleEnumerable { get; } = typeof(IEnumerable<double>);
 	/// <summary>
 	/// Gets the t object array.
 	/// </summary>
 	private static Type s_objectArray { get; } = typeof(object[]);
 	/// <summary>
 	/// Gets the t object enumerable.
 	/// </summary>
 	private static Type s_objectEnumerable { get; } = typeof(IEnumerable<object>);
 
 	/// <inheritdoc />
 	public bool CanDecompose(Type t)
 		=> t == s_complex;
 
 	/// <inheritdoc />
 	public bool CanRecompose(Type t)
 		=> t == s_doubleArray
 		|| t == s_objectArray
 		|| s_doubleEnumerable.IsAssignableFrom(t)
 		|| s_objectEnumerable.IsAssignableFrom(t);
 
 	/// <inheritdoc />
 	public bool TryDecompose(object obj, Type tobj, out object decomposed, out Type tdecomposed)
 	{
 		decomposed = null;
 		tdecomposed = s_doubleArray;
 
 		if (tobj != s_complex || obj is not Complex c)
 			return false;
 
 		decomposed = new[] { c.Real, c.Imaginary };
 		return true;
 	}
 
 	/// <inheritdoc />
 	public bool TryRecompose(object obj, Type tobj, Type trecomposed, out object recomposed)
 	{
 		recomposed = null;
 
 		if (trecomposed != s_complex)
 			return false;
 
 		// ie<double>
 		if (s_doubleEnumerable.IsAssignableFrom(tobj) && obj is IEnumerable<double> ied)
 		{
 			if (!ied.TryFirstTwo(out var values))
 				return false;
 
 			var (real, imag) = values;
 			recomposed = new Complex(real, imag);
 			return true;
 		}
 
 		// ie<obj>
 		if (s_objectEnumerable.IsAssignableFrom(tobj) && obj is IEnumerable<object> ieo)
 		{
 			if (!ieo.TryFirstTwo(out var values))
 				return false;
 
 			var (real, imag) = values;
 			if (real is not double dreal || imag is not double dimag)
 				return false;
 
 			recomposed = new Complex(dreal, dimag);
 			return true;
 		}
 
 		return false;
 	}
 }
diff --git a/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs b/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs
index 55496f243..d838d23af 100644
--- a/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs
+++ b/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs
@@ -1,199 +1,199 @@
 // 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.Immutable;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Common.Utilities;
 
 /// <summary>
 /// ABC for <see cref="AsyncEvent{TSender, TArgs}"/>, allowing for using instances thereof without knowing the underlying instance's type parameters.
 /// </summary>
 public abstract class AsyncEvent
 {
 	/// <summary>
 	/// Gets the name of this event.
 	/// </summary>
 	public string Name { get; }
 
 	/// <summary>
 	/// Prevents a default instance of the <see cref="AsyncEvent"/> class from being created.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	private protected AsyncEvent(string name)
 	{
 		this.Name = name;
 	}
 }
 
 /// <summary>
 /// Implementation of asynchronous event. The handlers of such events are executed asynchronously, but sequentially.
 /// </summary>
 /// <typeparam name="TSender">Type of the object that dispatches this event.</typeparam>
 /// <typeparam name="TArgs">Type of event argument object passed to this event's handlers.</typeparam>
 public sealed class AsyncEvent<TSender, TArgs> : AsyncEvent
 	where TArgs : AsyncEventArgs
 {
 	/// <summary>
-	/// Gets the maximum allotted execution time for all handlers. Any event which causes the handler to time out 
+	/// Gets the maximum allotted execution time for all handlers. Any event which causes the handler to time out
 	/// will raise a non-fatal <see cref="AsyncEventTimeoutException{TSender, TArgs}"/>.
 	/// </summary>
 	public TimeSpan MaximumExecutionTime { get; }
 
 	private readonly object _lock = new();
 	private ImmutableArray<AsyncEventHandler<TSender, TArgs>> _handlers;
 	private readonly AsyncEventExceptionHandler<TSender, TArgs> _exceptionHandler;
 
 	/// <summary>
 	/// Creates a new asynchronous event with specified name and exception handler.
 	/// </summary>
 	/// <param name="name">Name of this event.</param>
-	/// <param name="maxExecutionTime">Maximum handler execution time. A value of <see cref="System.TimeSpan.Zero"/> means infinite.</param>
+	/// <param name="maxExecutionTime">Maximum handler execution time. A value of <see cref="TimeSpan.Zero"/> means infinite.</param>
 	/// <param name="exceptionHandler">Delegate which handles exceptions caused by this event.</param>
 	public AsyncEvent(string name, TimeSpan maxExecutionTime, AsyncEventExceptionHandler<TSender, TArgs> exceptionHandler)
 		: base(name)
 	{
 		this._handlers = ImmutableArray<AsyncEventHandler<TSender, TArgs>>.Empty;
 		this._exceptionHandler = exceptionHandler;
 
 		this.MaximumExecutionTime = maxExecutionTime;
 	}
 
 	/// <summary>
 	/// Registers a new handler for this event.
 	/// </summary>
 	/// <param name="handler">Handler to register for this event.</param>
 	public void Register(AsyncEventHandler<TSender, TArgs> handler)
 	{
 		if (handler == null)
 			throw new ArgumentNullException(nameof(handler));
 
 		lock (this._lock)
 			this._handlers = this._handlers.Add(handler);
 	}
 
 	/// <summary>
 	/// Unregisters an existing handler from this event.
 	/// </summary>
 	/// <param name="handler">Handler to unregister from the event.</param>
 	public void Unregister(AsyncEventHandler<TSender, TArgs> handler)
 	{
 		if (handler == null)
 			throw new ArgumentNullException(nameof(handler));
 
 		lock (this._lock)
 			this._handlers = this._handlers.Remove(handler);
 	}
 
 	/// <summary>
 	/// Unregisters all existing handlers from this event.
 	/// </summary>
 	public void UnregisterAll() => this._handlers = ImmutableArray<AsyncEventHandler<TSender, TArgs>>.Empty;
 
 	/// <summary>
 	/// <para>Raises this event by invoking all of its registered handlers, in order of registration.</para>
 	/// <para>All exceptions throw during invocation will be handled by the event's registered exception handler.</para>
 	/// </summary>
 	/// <param name="sender">Object which raised this event.</param>
 	/// <param name="e">Arguments for this event.</param>
 	/// <param name="exceptionMode">Defines what to do with exceptions caught from handlers.</param>
 	/// <returns></returns>
 	public async Task InvokeAsync(TSender sender, TArgs e, AsyncEventExceptionMode exceptionMode = AsyncEventExceptionMode.Default)
 	{
 		var handlers = this._handlers;
 		if (handlers.Length == 0)
 			return;
 
 		// Collect exceptions
 		List<Exception> exceptions = null;
 		if ((exceptionMode & AsyncEventExceptionMode.ThrowAll) != 0)
 			exceptions = new List<Exception>(handlers.Length * 2 /* timeout + regular */);
 
 		// If we have a timeout configured, start the timeout task
 		var timeout = this.MaximumExecutionTime > TimeSpan.Zero ? Task.Delay(this.MaximumExecutionTime) : null;
 		foreach (var handler in handlers)
 		{
 			try
 			{
 				// Start the handler execution
 				var handlerTask = handler(sender, e);
 				if (handlerTask != null && timeout != null)
 				{
 					// If timeout is configured, wait for any task to finish
 					// If the timeout task finishes first, the handler is causing a timeout
 
 					var result = await Task.WhenAny(timeout, handlerTask).ConfigureAwait(false);
 					if (result == timeout)
 					{
 						timeout = null;
 						var timeoutEx = new AsyncEventTimeoutException<TSender, TArgs>(this, handler);
 
 						// Notify about the timeout and complete execution
 						if ((exceptionMode & AsyncEventExceptionMode.HandleNonFatal) == AsyncEventExceptionMode.HandleNonFatal)
 							this.HandleException(timeoutEx, handler, sender, e);
 
 						if ((exceptionMode & AsyncEventExceptionMode.ThrowNonFatal) == AsyncEventExceptionMode.ThrowNonFatal)
 							exceptions.Add(timeoutEx);
 
 						await handlerTask.ConfigureAwait(false);
 					}
 				}
 				else if (handlerTask != null)
 				{
 					// No timeout is configured, or timeout already expired, proceed as usual
 					await handlerTask.ConfigureAwait(false);
 				}
 
 				if (e.Handled)
 					break;
 			}
 			catch (Exception ex)
 			{
 				e.Handled = false;
 
 				if ((exceptionMode & AsyncEventExceptionMode.HandleFatal) == AsyncEventExceptionMode.HandleFatal)
 					this.HandleException(ex, handler, sender, e);
 
 				if ((exceptionMode & AsyncEventExceptionMode.ThrowFatal) == AsyncEventExceptionMode.ThrowFatal)
 					exceptions.Add(ex);
 			}
 		}
 
 		if ((exceptionMode & AsyncEventExceptionMode.ThrowAll) != 0 && exceptions.Count > 0)
 			throw new AggregateException("Exceptions were thrown during execution of the event's handlers.", exceptions);
 	}
 
 	/// <summary>
 	/// Handles the exception.
 	/// </summary>
 	/// <param name="ex">The ex.</param>
 	/// <param name="handler">The handler.</param>
 	/// <param name="sender">The sender.</param>
 	/// <param name="args">The args.</param>
 	private void HandleException(Exception ex, AsyncEventHandler<TSender, TArgs> handler, TSender sender, TArgs args)
 	{
 		if (this._exceptionHandler != null)
 			this._exceptionHandler(this, ex, handler, sender, args);
 	}
 }
diff --git a/DisCatSharp.Common/Utilities/AsyncManualResetEvent.cs b/DisCatSharp.Common/Utilities/AsyncManualResetEvent.cs
index 1dd49f83d..129a9fdb1 100644
--- a/DisCatSharp.Common/Utilities/AsyncManualResetEvent.cs
+++ b/DisCatSharp.Common/Utilities/AsyncManualResetEvent.cs
@@ -1,80 +1,80 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Common.Utilities;
 
 /// <summary>
-/// Represents a thread synchronization event that, when signaled, must be reset manually. Unlike <see cref="System.Threading.ManualResetEventSlim"/>, this event is asynchronous.
+/// Represents a thread synchronization event that, when signaled, must be reset manually. Unlike <see cref="ManualResetEventSlim"/>, this event is asynchronous.
 /// </summary>
 public sealed class AsyncManualResetEvent
 {
 	/// <summary>
 	/// Gets whether this event has been signaled.
 	/// </summary>
 	public bool IsSet => this._resetTcs?.Task?.IsCompleted == true;
 
 	private volatile TaskCompletionSource<bool> _resetTcs;
 
 	/// <summary>
 	/// Creates a new asynchronous synchronization event with initial state.
 	/// </summary>
 	/// <param name="initialState">Initial state of this event.</param>
 	public AsyncManualResetEvent(bool initialState)
 	{
 		this._resetTcs = new TaskCompletionSource<bool>();
 		if (initialState)
 			this._resetTcs.TrySetResult(initialState);
 	}
 
 	// Spawn a threadpool thread instead of making a task
 	// Maybe overkill, but I am less unsure of this than awaits and
 	// potentially cross-scheduler interactions
 	/// <summary>
 	/// Asynchronously signal this event.
 	/// </summary>
 	/// <returns></returns>
 	public Task SetAsync()
 		=> Task.Run(() => this._resetTcs.TrySetResult(true));
 
 	/// <summary>
 	/// Asynchronously wait for this event to be signaled.
 	/// </summary>
 	/// <returns></returns>
 	public Task WaitAsync()
 		=> this._resetTcs.Task;
 
 	/// <summary>
 	/// Reset this event's signal state to unsignaled.
 	/// </summary>
 	public void Reset()
 	{
 		while (true)
 		{
 			var tcs = this._resetTcs;
 			if (!tcs.Task.IsCompleted || Interlocked.CompareExchange(ref this._resetTcs, new TaskCompletionSource<bool>(), tcs) == tcs)
 				return;
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Utilities/Extensions.cs b/DisCatSharp.Common/Utilities/Extensions.cs
index 7777aa83f..ce4dee7a5 100644
--- a/DisCatSharp.Common/Utilities/Extensions.cs
+++ b/DisCatSharp.Common/Utilities/Extensions.cs
@@ -1,530 +1,530 @@
 // 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.Runtime.CompilerServices;
 
 namespace DisCatSharp.Common;
 
 /// <summary>
 /// Assortment of various extension and utility methods, designed to make working with various types a little easier.
 /// </summary>
 public static class Extensions
 {
 	/// <summary>
-	/// <para>Deconstructs a <see cref="System.Collections.Generic.Dictionary{TKey, TValue}"/> key-value pair item (<see cref="System.Collections.Generic.KeyValuePair{TKey, TValue}"/>) into 2 separate variables.</para>
-	/// <para>This allows for enumerating over dictionaries in foreach blocks by using a (k, v) tuple as the enumerator variable, instead of having to use a <see cref="System.Collections.Generic.KeyValuePair{TKey, TValue}"/> directly.</para>
+	/// <para>Deconstructs a <see cref="Dictionary{TKey, TValue}"/> key-value pair item (<see cref="KeyValuePair{TKey, TValue}"/>) into 2 separate variables.</para>
+	/// <para>This allows for enumerating over dictionaries in foreach blocks by using a (k, v) tuple as the enumerator variable, instead of having to use a <see cref="KeyValuePair{TKey, TValue}"/> directly.</para>
 	/// </summary>
 	/// <typeparam name="TKey">Type of dictionary item key.</typeparam>
 	/// <typeparam name="TValue">Type of dictionary item value.</typeparam>
 	/// <param name="kvp">Key-value pair to deconstruct.</param>
 	/// <param name="key">Deconstructed key.</param>
 	/// <param name="value">Deconstructed value.</param>
 	public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
 	{
 		key = kvp.Key;
 		value = kvp.Value;
 	}
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this sbyte num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == sbyte.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this byte num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this short num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == short.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this ushort num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this int num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == int.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this uint num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this long num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == long.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 	/// <summary>
 	/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 	/// </summary>
 	/// <param name="num">Number to calculate the length of.</param>
 	/// <returns>Calculated number length.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static int CalculateLength(this ulong num)
 		=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this sbyte num, sbyte min, sbyte max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this byte num, byte min, byte max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this short num, short min, short max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this ushort num, ushort min, ushort max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this int num, int min, int max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this uint num, uint min, uint max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this long num, long min, long max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this ulong num, ulong min, ulong max, bool inclusive = true)
 	{
 		if (min > max)
 		{
 			min ^= max;
 			max ^= min;
 			min ^= max;
 		}
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this float num, float min, float max, bool inclusive = true)
 	{
 		if (min > max)
 			return false;
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Tests whether given value is in supplied range, optionally allowing it to be an exclusive check.
 	/// </summary>
 	/// <param name="num">Number to test.</param>
 	/// <param name="min">Lower bound of the range.</param>
 	/// <param name="max">Upper bound of the range.</param>
 	/// <param name="inclusive">Whether the check is to be inclusive.</param>
 	/// <returns>Whether the value is in range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsInRange(this double num, double min, double max, bool inclusive = true)
 	{
 		if (min > max)
 			return false;
 
 		return inclusive ? num >= min && num <= max : num > min && num < max;
 	}
 
 	/// <summary>
 	/// Returns whether supplied character is in any of the following ranges: a-z, A-Z, 0-9.
 	/// </summary>
 	/// <param name="c">Character to test.</param>
 	/// <returns>Whether the character is in basic alphanumeric character range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsBasicAlphanumeric(this char c)
 		=> (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
 
 	/// <summary>
 	/// Returns whether supplied character is in the 0-9 range.
 	/// </summary>
 	/// <param name="c">Character to test.</param>
 	/// <returns>Whether the character is in basic numeric digit character range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsBasicDigit(this char c)
 		=> c >= '0' && c <= '9';
 
 	/// <summary>
 	/// Returns whether supplied character is in the a-z or A-Z range.
 	/// </summary>
 	/// <param name="c">Character to test.</param>
 	/// <returns>Whether the character is in basic letter character range.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool IsBasicLetter(this char c)
 		=> (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 
 	/// <summary>
 	/// Tests whether given string ends with given character.
 	/// </summary>
 	/// <param name="s">String to test.</param>
 	/// <param name="c">Character to test for.</param>
 	/// <returns>Whether the supplied string ends with supplied character.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool EndsWithCharacter(this string s, char c)
 		=> s.Length >= 1 && s[^1] == c;
 
 	/// <summary>
 	/// Tests whether given string starts with given character.
 	/// </summary>
 	/// <param name="s">String to test.</param>
 	/// <param name="c">Character to test for.</param>
 	/// <returns>Whether the supplied string starts with supplied character.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool StartsWithCharacter(this string s, char c)
 		=> s.Length >= 1 && s[0] == c;
 
 	// https://stackoverflow.com/questions/9545619/a-fast-hash-function-for-string-in-c-sharp
 	// Calls are inlined to call the underlying method directly
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this ReadOnlySpan<char> chars)
 		=> Knuth(chars);
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this Span<char> chars)
 		=> Knuth(chars);
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this ReadOnlyMemory<char> chars)
 		=> Knuth(chars.Span);
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this Memory<char> chars)
 		=> Knuth(chars.Span);
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this ArraySegment<char> chars)
 		=> Knuth(chars.AsSpan());
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this char[] chars)
 		=> Knuth(chars.AsSpan());
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <param name="start">Offset in the array to start calculating from.</param>
 	/// <param name="count">Number of characters to compute the hash from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this char[] chars, int start, int count)
 		=> Knuth(chars.AsSpan(start, count));
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this string chars)
 		=> Knuth(chars.AsSpan());
 
 	/// <summary>
 	/// Computes a 64-bit Knuth hash from supplied characters.
 	/// </summary>
 	/// <param name="chars">Characters to compute the hash value from.</param>
 	/// <param name="start">Offset in the array to start calculating from.</param>
 	/// <param name="count">Number of characters to compute the hash from.</param>
 	/// <returns>Computer 64-bit Knuth hash.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKnuthHash(this string chars, int start, int count)
 		=> Knuth(chars.AsSpan(start, count));
 
 	/// <summary>
 	/// Gets the two first elements of the <see cref="IEnumerable{T}"/>, if they exist.
 	/// </summary>
 	/// <param name="enumerable">The enumerable.</param>
 	/// <param name="values">The output values. Undefined if <code>false</code> is returned.</param>
 	/// <returns>Whether the <see cref="IEnumerable{T}"/> contained enough elements.</returns>
 	internal static bool TryFirstTwo<T>(this IEnumerable<T> enumerable, out (T first, T second) values)
 	{
 		values = default;
 
 		using var enumerator = enumerable.GetEnumerator();
 
 		if (!enumerator.MoveNext())
 			return false;
 
 		var first = enumerator.Current;
 
 		if (!enumerator.MoveNext())
 			return false;
 
 
 		values = (first, enumerator.Current);
 		return true;
 	}
 
 	/// <summary>
 	/// Knuths the.
 	/// </summary>
 	/// <param name="chars">The chars.</param>
 	/// <returns>An ulong.</returns>
 	private static ulong Knuth(ReadOnlySpan<char> chars)
 	{
 		var hash = 3074457345618258791ul;
 		foreach (var ch in chars)
 			hash = (hash + ch) * 3074457345618258799ul;
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Removes the first item matching the predicate from the list.
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	/// <param name="list"></param>
 	/// <param name="predicate"></param>
 	/// <returns>Whether an item was removed.</returns>
 	internal static bool RemoveFirst<T>(this IList<T> list, Predicate<T> predicate)
 	{
 		for (var i = 0; i < list.Count; i++)
 		{
 			if (predicate(list[i]))
 			{
 				list.RemoveAt(i);
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Populates an array with the given value.
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	/// <param name="arr"></param>
 	/// <param name="value"></param>
 	internal static void Populate<T>(this T[] arr, T value)
 	{
 		for (var i = 0; i < arr.Length; i++)
 		{
 			arr[i] = value;
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs b/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs
index dd2856620..5cc48ff5a 100644
--- a/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs
@@ -1,320 +1,320 @@
 // 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;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Interactivity.Enums;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// The pagination request.
 	/// </summary>
 	internal class PaginationRequest : IPaginationRequest
 	{
 		private TaskCompletionSource<bool> _tcs;
 		private readonly CancellationTokenSource _ct;
 		private readonly TimeSpan _timeout;
 		private readonly List<Page> _pages;
 		private readonly PaginationBehaviour _behaviour;
 		private readonly DiscordMessage _message;
 		private readonly PaginationEmojis _emojis;
 		private readonly DiscordUser _user;
 		private int _index;
 
 		/// <summary>
 		/// Creates a new Pagination request
 		/// </summary>
 		/// <param name="message">Message to paginate</param>
 		/// <param name="user">User to allow control for</param>
 		/// <param name="behaviour">Behaviour during pagination</param>
 		/// <param name="deletion">Behavior on pagination end</param>
 		/// <param name="emojis">Emojis for this pagination object</param>
 		/// <param name="timeout">Timeout time</param>
 		/// <param name="pages">Pagination pages</param>
 		internal PaginationRequest(DiscordMessage message, DiscordUser user, PaginationBehaviour behaviour, PaginationDeletion deletion,
 			PaginationEmojis emojis, TimeSpan timeout, IEnumerable<Page> pages)
 		{
 			this._tcs = new TaskCompletionSource<bool>();
 			this._ct = new CancellationTokenSource(timeout);
 			this._ct.Token.Register(() => this._tcs.TrySetResult(true));
 			this._timeout = timeout;
 
 			this._message = message;
 			this._user = user;
 
 			this.PaginationDeletion = deletion;
 			this._behaviour = behaviour;
 			this._emojis = emojis;
 
 			this._pages = new List<Page>();
 			foreach (var p in pages)
 			{
 				this._pages.Add(p);
 			}
 		}
 
 		/// <summary>
 		/// Gets the page count.
 		/// </summary>
 		public int PageCount => this._pages.Count;
 
 		/// <summary>
 		/// Gets the pagination deletion.
 		/// </summary>
 		public PaginationDeletion PaginationDeletion { get; }
 
 		/// <summary>
 		/// Gets the page async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<Page> GetPageAsync()
 		{
 			await Task.Yield();
 
 			return this._pages[this._index];
 		}
 
 		/// <summary>
 		/// Skips the left async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task SkipLeftAsync()
 		{
 			await Task.Yield();
 
 			this._index = 0;
 		}
 
 		/// <summary>
 		/// Skips the right async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task SkipRightAsync()
 		{
 			await Task.Yield();
 
 			this._index = this._pages.Count - 1;
 		}
 
 		/// <summary>
 		/// Nexts the page async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task NextPageAsync()
 		{
 			await Task.Yield();
 
 			switch (this._behaviour)
 			{
 				case PaginationBehaviour.Ignore:
 					if (this._index == this._pages.Count - 1)
 						break;
 					else
 						this._index++;
 
 					break;
 
 				case PaginationBehaviour.WrapAround:
 					if (this._index == this._pages.Count - 1)
 						this._index = 0;
 					else
 						this._index++;
 
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Previous the page async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task PreviousPageAsync()
 		{
 			await Task.Yield();
 
 			switch (this._behaviour)
 			{
 				case PaginationBehaviour.Ignore:
 					if (this._index == 0)
 						break;
 					else
 						this._index--;
 
 					break;
 
 				case PaginationBehaviour.WrapAround:
 					if (this._index == 0)
 						this._index = this._pages.Count - 1;
 					else
 						this._index--;
 
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Gets the buttons async.
 		/// </summary>
-		/// <returns><see cref="System.NotSupportedException"/></returns>
+		/// <returns><see cref="NotSupportedException"/></returns>
 #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
 		public async Task<IEnumerable<DiscordButtonComponent>> GetButtonsAsync()
 #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
 			=> throw new NotSupportedException("This request does not support buttons.");
 
 		/// <summary>
 		/// Gets the emojis async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<PaginationEmojis> GetEmojisAsync()
 		{
 			await Task.Yield();
 
 			return this._emojis;
 		}
 
 		/// <summary>
 		/// Gets the message async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<DiscordMessage> GetMessageAsync()
 		{
 			await Task.Yield();
 
 			return this._message;
 		}
 
 		/// <summary>
 		/// Gets the user async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<DiscordUser> GetUserAsync()
 		{
 			await Task.Yield();
 
 			return this._user;
 		}
 
 		/// <summary>
 		/// Dos the cleanup async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task DoCleanupAsync()
 		{
 			switch (this.PaginationDeletion)
 			{
 				case PaginationDeletion.DeleteEmojis:
 					await this._message.DeleteAllReactionsAsync().ConfigureAwait(false);
 					break;
 
 				case PaginationDeletion.DeleteMessage:
 					await this._message.DeleteAsync().ConfigureAwait(false);
 					break;
 
 				case PaginationDeletion.KeepEmojis:
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Gets the task completion source async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<TaskCompletionSource<bool>> GetTaskCompletionSourceAsync()
 		{
 			await Task.Yield();
 
 			return this._tcs;
 		}
 
 		~PaginationRequest()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Disposes this PaginationRequest.
 		/// </summary>
 		public void Dispose()
 		{
 			this._ct.Dispose();
 			this._tcs = null;
 		}
 	}
 }
 
 namespace DisCatSharp.Interactivity
 {
 	/// <summary>
 	/// The pagination emojis.
 	/// </summary>
 	public class PaginationEmojis
 	{
 		public DiscordEmoji SkipLeft;
 		public DiscordEmoji SkipRight;
 		public DiscordEmoji Left;
 		public DiscordEmoji Right;
 		public DiscordEmoji Stop;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="PaginationEmojis"/> class.
 		/// </summary>
 		public PaginationEmojis()
 		{
 			this.Left = DiscordEmoji.FromUnicode("◀");
 			this.Right = DiscordEmoji.FromUnicode("▶");
 			this.SkipLeft = DiscordEmoji.FromUnicode("⏮");
 			this.SkipRight = DiscordEmoji.FromUnicode("⏭");
 			this.Stop = DiscordEmoji.FromUnicode("⏹");
 		}
 	}
 
 	/// <summary>
 	/// The page.
 	/// </summary>
 	public class Page
 	{
 		/// <summary>
 		/// Gets or sets the content.
 		/// </summary>
 		public string Content { get; set; }
 		/// <summary>
 		/// Gets or sets the embed.
 		/// </summary>
 		public DiscordEmbed Embed { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Page"/> class.
 		/// </summary>
 		/// <param name="content">The content.</param>
 		/// <param name="embed">The embed.</param>
 		public Page(string content = "", DiscordEmbedBuilder embed = null)
 		{
 			this.Content = content;
 			this.Embed = embed?.Build();
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/Extensions/ChannelExtensions.cs b/DisCatSharp.Interactivity/Extensions/ChannelExtensions.cs
index 2f9e96daa..5710cd186 100644
--- a/DisCatSharp.Interactivity/Extensions/ChannelExtensions.cs
+++ b/DisCatSharp.Interactivity/Extensions/ChannelExtensions.cs
@@ -1,150 +1,150 @@
 // 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;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 
 namespace DisCatSharp.Interactivity.Extensions;
 
 /// <summary>
 /// Interactivity extension methods for <see cref="DisCatSharp.Entities.DiscordChannel"/>.
 /// </summary>
 public static class ChannelExtensions
 {
 	/// <summary>
 	/// Waits for the next message sent in this channel that satisfies the predicate.
 	/// </summary>
 	/// <param name="channel">The channel to monitor.</param>
 	/// <param name="predicate">A predicate that should return <see langword="true"/> if a message matches.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task<InteractivityResult<DiscordMessage>> GetNextMessageAsync(this DiscordChannel channel, Func<DiscordMessage, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(channel).WaitForMessageAsync(msg => msg.ChannelId == channel.Id && predicate(msg), timeoutOverride);
 
 	/// <summary>
 	/// Waits for the next message sent in this channel.
 	/// </summary>
 	/// <param name="channel">The channel to monitor.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task<InteractivityResult<DiscordMessage>> GetNextMessageAsync(this DiscordChannel channel, TimeSpan? timeoutOverride = null)
 		=> channel.GetNextMessageAsync(msg => true, timeoutOverride);
 
 	/// <summary>
 	/// Waits for the next message sent in this channel from a specific user.
 	/// </summary>
 	/// <param name="channel">The channel to monitor.</param>
 	/// <param name="user">The target user.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task<InteractivityResult<DiscordMessage>> GetNextMessageAsync(this DiscordChannel channel, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> channel.GetNextMessageAsync(msg => msg.Author.Id == user.Id, timeoutOverride);
 
 	/// <summary>
 	/// Waits for a specific user to start typing in this channel.
 	/// </summary>
 	/// <param name="channel">The target channel.</param>
 	/// <param name="user">The target user.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(this DiscordChannel channel, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(channel).WaitForUserTypingAsync(user, channel, timeoutOverride);
 
 
 	/// <summary>
 	/// Sends a new paginated message.
 	/// </summary>
 	/// <param name="channel">Target channel.</param>
 	/// <param name="user">The user that will be able to control the pages.</param>
 	/// <param name="pages">A collection of <see cref="Page"/> to display.</param>
 	/// <param name="emojis">Pagination emojis.</param>
 	/// <param name="behaviour">Pagination behaviour (when hitting max and min indices).</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task SendPaginatedMessageAsync(this DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationEmojis emojis, PaginationBehaviour? behaviour = default, PaginationDeletion? deletion = default, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(channel).SendPaginatedMessageAsync(channel, user, pages, emojis, behaviour, deletion, timeoutOverride);
 
 	/// <summary>
 	/// Sends a new paginated message with buttons.
 	/// </summary>
 	/// <param name="channel">Target channel.</param>
 	/// <param name="user">The user that will be able to control the pages.</param>
 	/// <param name="pages">A collection of <see cref="Page"/> to display.</param>
 	/// <param name="buttons">Pagination buttons (leave null to default to ones on configuration).</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task SendPaginatedMessageAsync(this DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 		=> GetInteractivity(channel).SendPaginatedMessageAsync(channel, user, pages, buttons, behaviour, deletion, token);
 
 	/// <inheritdoc cref="SendPaginatedMessageAsync(DiscordChannel, DiscordUser, IEnumerable{Page}, PaginationButtons, PaginationBehaviour?, ButtonPaginationBehavior?, CancellationToken)"/>
 	public static Task SendPaginatedMessageAsync(this DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 		=> channel.SendPaginatedMessageAsync(user, pages, default, behaviour, deletion, token);
 
 	/// <summary>
 	/// Sends a new paginated message with buttons.
 	/// </summary>
 	/// <param name="channel">Target channel.</param>
 	/// <param name="user">The user that will be able to control the pages.</param>
 	/// <param name="pages">A collection of <see cref="Page"/> to display.</param>
 	/// <param name="buttons">Pagination buttons (leave null to default to ones on configuration).</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
 	public static Task SendPaginatedMessageAsync(this DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons, TimeSpan? timeoutOverride, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 		=> GetInteractivity(channel).SendPaginatedMessageAsync(channel, user, pages, buttons, timeoutOverride, behaviour, deletion);
 
 
 	/// <summary>
 	/// Sends the paginated message async.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="user">The user.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	/// <param name="behaviour">The behaviour.</param>
 	/// <param name="deletion">The deletion.</param>
 	/// <returns>A Task.</returns>
 	public static Task SendPaginatedMessageAsync(this DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, TimeSpan? timeoutOverride, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 		=> channel.SendPaginatedMessageAsync(user, pages, default, timeoutOverride, behaviour, deletion);
 
 	/// <summary>
 	/// Retrieves an interactivity instance from a channel instance.
 	/// </summary>
 	private static InteractivityExtension GetInteractivity(DiscordChannel channel)
 	{
 		var client = (DiscordClient)channel.Discord;
 		var interactivity = client.GetInteractivity();
 
 		return interactivity ?? throw new InvalidOperationException($"Interactivity is not enabled for this {(client.IsShard ? "shard" : "client")}.");
 	}
 }
diff --git a/DisCatSharp.Interactivity/Extensions/ClientExtensions.cs b/DisCatSharp.Interactivity/Extensions/ClientExtensions.cs
index 036fe3757..80279d85e 100644
--- a/DisCatSharp.Interactivity/Extensions/ClientExtensions.cs
+++ b/DisCatSharp.Interactivity/Extensions/ClientExtensions.cs
@@ -1,99 +1,99 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Interactivity.Extensions;
 
 /// <summary>
 /// Interactivity extension methods for <see cref="DiscordClient"/> and <see cref="DiscordShardedClient"/>.
 /// </summary>
 public static class ClientExtensions
 {
 	/// <summary>
 	/// Enables interactivity for this <see cref="DiscordClient"/> instance.
 	/// </summary>
 	/// <param name="client">The client to enable interactivity for.</param>
 	/// <param name="configuration">A configuration instance. Default configuration values will be used if none is provided.</param>
 	/// <returns>A brand new <see cref="InteractivityExtension"/> instance.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity has already been enabled for the client instance.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity has already been enabled for the client instance.</exception>
 	public static InteractivityExtension UseInteractivity(this DiscordClient client, InteractivityConfiguration configuration = null)
 	{
 		if (client.GetExtension<InteractivityExtension>() != null) throw new InvalidOperationException($"Interactivity is already enabled for this {(client.IsShard ? "shard" : "client")}.");
 
 		configuration ??= new InteractivityConfiguration();
 		var extension = new InteractivityExtension(configuration);
 		client.AddExtension(extension);
 
 		return extension;
 	}
 
 	/// <summary>
 	/// Enables interactivity for each shard.
 	/// </summary>
 	/// <param name="client">The shard client to enable interactivity for.</param>
 	/// <param name="configuration">Configuration to use for all shards. If one isn't provided, default configuration values will be used.</param>
 	/// <returns>A dictionary containing new <see cref="InteractivityExtension"/> instances for each shard.</returns>
 	public static async Task<IReadOnlyDictionary<int, InteractivityExtension>> UseInteractivityAsync(this DiscordShardedClient client, InteractivityConfiguration configuration = null)
 	{
 		var extensions = new Dictionary<int, InteractivityExtension>();
 		await client.InitializeShardsAsync().ConfigureAwait(false);
 
 		foreach (var shard in client.ShardClients.Select(xkvp => xkvp.Value))
 		{
 			var extension = shard.GetExtension<InteractivityExtension>() ?? shard.UseInteractivity(configuration);
 			extensions.Add(shard.ShardId, extension);
 		}
 
 		return new ReadOnlyDictionary<int, InteractivityExtension>(extensions);
 	}
 
 	/// <summary>
 	/// Retrieves the registered <see cref="InteractivityExtension"/> instance for this client.
 	/// </summary>
 	/// <param name="client">The client to retrieve an <see cref="InteractivityExtension"/> instance from.</param>
 	/// <returns>An existing <see cref="InteractivityExtension"/> instance, or <see langword="null"/> if interactivity is not enabled for the <see cref="DiscordClient"/> instance.</returns>
 	public static InteractivityExtension GetInteractivity(this DiscordClient client)
 		=> client.GetExtension<InteractivityExtension>();
 
 	/// <summary>
 	/// Retrieves a <see cref="InteractivityExtension"/> instance for each shard.
 	/// </summary>
 	/// <param name="client">The shard client to retrieve interactivity instances from.</param>
 	/// <returns>A dictionary containing <see cref="InteractivityExtension"/> instances for each shard.</returns>
 	public static async Task<ReadOnlyDictionary<int, InteractivityExtension>> GetInteractivityAsync(this DiscordShardedClient client)
 	{
 		await client.InitializeShardsAsync().ConfigureAwait(false);
 		var extensions = new Dictionary<int, InteractivityExtension>();
 
 		foreach (var shard in client.ShardClients.Select(xkvp => xkvp.Value))
 		{
 			extensions.Add(shard.ShardId, shard.GetExtension<InteractivityExtension>());
 		}
 
 		return new ReadOnlyDictionary<int, InteractivityExtension>(extensions);
 	}
 }
diff --git a/DisCatSharp.Interactivity/Extensions/MessageExtensions.cs b/DisCatSharp.Interactivity/Extensions/MessageExtensions.cs
index 215cb40a3..735170684 100644
--- a/DisCatSharp.Interactivity/Extensions/MessageExtensions.cs
+++ b/DisCatSharp.Interactivity/Extensions/MessageExtensions.cs
@@ -1,243 +1,243 @@
 // 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.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 
 namespace DisCatSharp.Interactivity.Extensions;
 
 /// <summary>
 /// Interactivity extension methods for <see cref="DisCatSharp.Entities.DiscordMessage"/>.
 /// </summary>
 public static class MessageExtensions
 {
 	/// <summary>
 	/// Waits for the next message that has the same author and channel as this message.
 	/// </summary>
 	/// <param name="message">Original message.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
 	public static Task<InteractivityResult<DiscordMessage>> GetNextMessageAsync(this DiscordMessage message, TimeSpan? timeoutOverride = null)
 		=> message.Channel.GetNextMessageAsync(message.Author, timeoutOverride);
 
 	/// <summary>
 	/// Waits for the next message with the same author and channel as this message, which also satisfies a predicate.
 	/// </summary>
 	/// <param name="message">Original message.</param>
 	/// <param name="predicate">A predicate that should return <see langword="true"/> if a message matches.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
 	public static Task<InteractivityResult<DiscordMessage>> GetNextMessageAsync(this DiscordMessage message, Func<DiscordMessage, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> message.Channel.GetNextMessageAsync(msg => msg.Author.Id == message.Author.Id && message.ChannelId == msg.ChannelId && predicate(msg), timeoutOverride);
 	/// <summary>
 	/// Waits for any button to be pressed on the specified message.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message)
 		=> GetInteractivity(message).WaitForButtonAsync(message);
 
 	/// <summary>
 	/// Waits for any button to be pressed on the specified message.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForButtonAsync(message, timeoutOverride);
 	/// <summary>
 	/// Waits for any button to be pressed on the specified message.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, CancellationToken token)
 		=> GetInteractivity(message).WaitForButtonAsync(message, token);
 	/// <summary>
 	/// Waits for a button with the specified Id to be pressed on the specified message.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the button to wait for.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForButtonAsync(message, id, timeoutOverride);
 
 	/// <summary>
 	/// Waits for a button with the specified Id to be pressed on the specified message.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the button to wait for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, string id, CancellationToken token)
 		=> GetInteractivity(message).WaitForButtonAsync(message, id, token);
 
 	/// <summary>
 	/// Waits for any button to be pressed on the specified message by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait for button input from.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForButtonAsync(message, user, timeoutOverride);
 
 	/// <summary>
 	/// Waits for any button to be pressed on the specified message by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait for button input from.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, DiscordUser user, CancellationToken token)
 		=> GetInteractivity(message).WaitForButtonAsync(message, user, token);
 
 	/// <summary>
 	/// Waits for any button to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="predicate">The predicate to filter interactions by.</param>
 	/// <param name="timeoutOverride">Override the timeout specified in <see cref="InteractivityConfiguration"/></param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForButtonAsync(message, predicate, timeoutOverride);
 
 	/// <summary>
 	/// Waits for any button to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="predicate">The predicate to filter interactions by.</param>
-	/// <param name="token">A token to cancel interactivity with at any time. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
+	/// <param name="token">A token to cancel interactivity with at any time. Pass <see cref="CancellationToken.None"/> to wait indefinitely.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(this DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 		=> GetInteractivity(message).WaitForButtonAsync(message, predicate, token);
 
 	/// <summary>
 	/// Waits for any dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait for.</param>
 	/// <param name="predicate">A filter predicate.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the message doesn't contain any dropdowns</exception>
+	/// <exception cref="ArgumentException">Thrown when the message doesn't contain any dropdowns</exception>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(this DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForSelectAsync(message, predicate, timeoutOverride);
 
 
 	/// <summary>
 	/// Waits for any dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait for.</param>
 	/// <param name="predicate">A filter predicate.</param>
-	/// <param name="token">A token that can be used to cancel interactivity. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the message doesn't contain any dropdowns</exception>
+	/// <param name="token">A token that can be used to cancel interactivity. Pass <see cref="CancellationToken.None"/> to wait indefinitely.</param>
+	/// <exception cref="ArgumentException">Thrown when the message doesn't contain any dropdowns</exception>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(this DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 		=> GetInteractivity(message).WaitForSelectAsync(message, predicate, token);
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait for.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(this DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForSelectAsync(message, id, timeoutOverride);
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(this DiscordMessage message, string id, CancellationToken token)
 		=> GetInteractivity(message).WaitForSelectAsync(message, id, token);
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait for.</param>
 	/// <param name="id">The Id of the dropdown to wait for.</param>
 	/// <param name="timeoutOverride"></param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(this DiscordMessage message, DiscordUser user, string id, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForSelectAsync(message, user, id, timeoutOverride);
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait for.</param>
 	/// <param name="id">The Id of the dropdown to wait for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public static Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(this DiscordMessage message, DiscordUser user, string id, CancellationToken token)
    => GetInteractivity(message).WaitForSelectAsync(message, user, id, token);
 
 	/// <summary>
 	/// Waits for a reaction on this message from a specific user.
 	/// </summary>
 	/// <param name="message">Target message.</param>
 	/// <param name="user">The target user.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
 	public static Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(this DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForReactionAsync(message, user, timeoutOverride);
 
 	/// <summary>
 	/// Waits for a specific reaction on this message from the specified user.
 	/// </summary>
 	/// <param name="message">Target message.</param>
 	/// <param name="user">The target user.</param>
 	/// <param name="emoji">The target emoji.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
 	public static Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(this DiscordMessage message, DiscordUser user, DiscordEmoji emoji, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).WaitForReactionAsync(e => e.Emoji == emoji, message, user, timeoutOverride);
 
 	/// <summary>
 	/// Collects all reactions on this message within the timeout duration.
 	/// </summary>
 	/// <param name="message">The message to collect reactions from.</param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
 	public static Task<ReadOnlyCollection<Reaction>> CollectReactionsAsync(this DiscordMessage message, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).CollectReactionsAsync(message, timeoutOverride);
 
 
 	/// <summary>
 	/// Begins a poll using this message.
 	/// </summary>
 	/// <param name="message">Target message.</param>
 	/// <param name="emojis">Options for this poll.</param>
 	/// <param name="behaviorOverride">Overrides the action set in <see cref="InteractivityConfiguration.PaginationBehaviour"/></param>
 	/// <param name="timeoutOverride">Overrides the timeout set in <see cref="InteractivityConfiguration.Timeout"/></param>
-	/// <exception cref="System.InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+	/// <exception cref="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
 	public static Task<ReadOnlyCollection<PollEmoji>> DoPollAsync(this DiscordMessage message, IEnumerable<DiscordEmoji> emojis, PollBehaviour? behaviorOverride = null, TimeSpan? timeoutOverride = null)
 		=> GetInteractivity(message).DoPollAsync(message, emojis, behaviorOverride, timeoutOverride);
 
 	/// <summary>
 	/// Retrieves an interactivity instance from a message instance.
 	/// </summary>
 	internal static InteractivityExtension GetInteractivity(DiscordMessage message)
 	{
 		var client = (DiscordClient)message.Discord;
 		var interactivity = client.GetInteractivity();
 
 		return interactivity ?? throw new InvalidOperationException($"Interactivity is not enabled for this {(client.IsShard ? "shard" : "client")}.");
 	}
 }
diff --git a/DisCatSharp.Interactivity/InteractivityExtension.cs b/DisCatSharp.Interactivity/InteractivityExtension.cs
index 42cfda735..c0fa81fed 100644
--- a/DisCatSharp.Interactivity/InteractivityExtension.cs
+++ b/DisCatSharp.Interactivity/InteractivityExtension.cs
@@ -1,971 +1,971 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 
 namespace DisCatSharp.Interactivity;
 
 /// <summary>
 /// Extension class for DisCatSharp.Interactivity
 /// </summary>
 public class InteractivityExtension : BaseExtension
 {
 
 	/// <summary>
 	/// Gets the config.
 	/// </summary>
 	internal InteractivityConfiguration Config { get; }
 
 	private EventWaiter<MessageCreateEventArgs> _messageCreatedWaiter;
 
 	private EventWaiter<MessageReactionAddEventArgs> _messageReactionAddWaiter;
 
 	private EventWaiter<TypingStartEventArgs> _typingStartWaiter;
 
 	private EventWaiter<ComponentInteractionCreateEventArgs> _modalInteractionWaiter;
 
 	private EventWaiter<ComponentInteractionCreateEventArgs> _componentInteractionWaiter;
 
 	private ComponentEventWaiter _componentEventWaiter;
 
 	private ModalEventWaiter _modalEventWaiter;
 
 	private ReactionCollector _reactionCollector;
 
 	private Poller _poller;
 
 	private Paginator _paginator;
 	private  ComponentPaginator _compPaginator;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="InteractivityExtension"/> class.
 	/// </summary>
 	/// <param name="cfg">The configuration.</param>
 	internal InteractivityExtension(InteractivityConfiguration cfg)
 	{
 		this.Config = new InteractivityConfiguration(cfg);
 	}
 
 	/// <summary>
 	/// Setups the Interactivity Extension.
 	/// </summary>
 	/// <param name="client">Discord client.</param>
 	protected internal override void Setup(DiscordClient client)
 	{
 		this.Client = client;
 		this._messageCreatedWaiter = new EventWaiter<MessageCreateEventArgs>(this.Client);
 		this._messageReactionAddWaiter = new EventWaiter<MessageReactionAddEventArgs>(this.Client);
 		this._componentInteractionWaiter = new EventWaiter<ComponentInteractionCreateEventArgs>(this.Client);
 		this._modalInteractionWaiter = new EventWaiter<ComponentInteractionCreateEventArgs>(this.Client);
 		this._typingStartWaiter = new EventWaiter<TypingStartEventArgs>(this.Client);
 		this._poller = new Poller(this.Client);
 		this._reactionCollector = new ReactionCollector(this.Client);
 		this._paginator = new Paginator(this.Client);
 		this._compPaginator = new ComponentPaginator(this.Client, this.Config);
 		this._componentEventWaiter = new ComponentEventWaiter(this.Client, this.Config);
 		this._modalEventWaiter = new ModalEventWaiter(this.Client, this.Config);
 
 	}
 
 	/// <summary>
 	/// Makes a poll and returns poll results.
 	/// </summary>
 	/// <param name="m">Message to create poll on.</param>
 	/// <param name="emojis">Emojis to use for this poll.</param>
 	/// <param name="behaviour">What to do when the poll ends.</param>
 	/// <param name="timeout">Override timeout period.</param>
 	/// <returns></returns>
 	public async Task<ReadOnlyCollection<PollEmoji>> DoPollAsync(DiscordMessage m, IEnumerable<DiscordEmoji> emojis, PollBehaviour? behaviour = default, TimeSpan? timeout = null)
 	{
 		if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No reaction intents are enabled.");
 
 		if (!emojis.Any())
 			throw new ArgumentException("You need to provide at least one emoji for a poll!");
 
 		foreach (var em in emojis)
 			await m.CreateReactionAsync(em).ConfigureAwait(false);
 
 		var res = await this._poller.DoPollAsync(new PollRequest(m, timeout ?? this.Config.Timeout, emojis)).ConfigureAwait(false);
 
 		var pollBehaviour = behaviour ?? this.Config.PollBehaviour;
 		var thisMember = await m.Channel.Guild.GetMemberAsync(this.Client.CurrentUser.Id).ConfigureAwait(false);
 
 		if (pollBehaviour == PollBehaviour.DeleteEmojis && m.Channel.PermissionsFor(thisMember).HasPermission(Permissions.ManageMessages))
 			await m.DeleteAllReactionsAsync().ConfigureAwait(false);
 
 		return new ReadOnlyCollection<PollEmoji>(res.ToList());
 	}
 
 	/// <summary>
 	/// Waits for any button in the specified collection to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="buttons">A collection of buttons to listen for.</param>
 	/// <param name="timeoutOverride">Override the timeout period in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, IEnumerable<DiscordButtonComponent> buttons, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, buttons, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button in the specified collection to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="buttons">A collection of buttons to listen for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, IEnumerable<DiscordButtonComponent> buttons, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!buttons.Any())
 			throw new ArgumentException("You must specify at least one button to listen for.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Provided Message does not contain any button components.");
 
 		var res = await this._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message,
 				c =>
 					c.Interaction.Data.ComponentType == ComponentType.Button &&
 					buttons.Any(b => b.CustomId == c.Id), token)).ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(res is null, res);
 	}
 
 	/// <summary>
 	/// Waits for a user modal submit.
 	/// </summary>
 	/// <param name="customId">The custom id of the modal to wait for.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the modal.</returns>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForModalAsync(string customId, TimeSpan? timeoutOverride = null)
 		=> this.WaitForModalAsync(customId, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a user modal submit.
 	/// </summary>
 	/// <param name="customId">The custom id of the modal to wait for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the modal.</returns>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForModalAsync(string customId, CancellationToken token)
 	{
 		var result =
 			await this
 			._modalEventWaiter
 			.WaitForModalMatchAsync(new ModalMatchRequest(customId, c => c.Interaction.Type == InteractionType.ModalSubmit, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		var ids = message.Components.SelectMany(m => m.Components).Select(c => c.CustomId);
 
 		var result =
 			await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType == ComponentType.Button && ids.Contains(c.Id), token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="user">The user to wait for the button press from.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, user, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="user">The user to wait for the button press from.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, DiscordUser user, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.User == user, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 
 	}
 
 	/// <summary>
 	/// Waits for a button with the specified Id to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="id">The Id of the button to wait for.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the operation.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, id, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a button with the specified Id to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="id">The Id of the button to wait for.</param>
 	/// <param name="token">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the operation.</returns>
-	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
+	/// <exception cref="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, string id, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		if (!message.Components.SelectMany(c => c.Components).OfType<DiscordButtonComponent>().Any(c => c.CustomId == id))
 			throw new ArgumentException($"Message does not contain button with Id of '{id}'.");
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.Id == id, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for any button to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="predicate">The predicate to filter interactions by.</param>
 	/// <param name="timeoutOverride">Override the timeout specified in <see cref="InteractivityConfiguration"/></param>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, predicate, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="predicate">The predicate to filter interactions by.</param>
-	/// <param name="token">A token to cancel interactivity with at any time. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
+	/// <param name="token">A token to cancel interactivity with at any time. Pass <see cref="CancellationToken.None"/> to wait indefinitely.</param>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType is ComponentType.Button && predicate(c), token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 
 	/// <summary>
 	/// Waits for any dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait for.</param>
 	/// <param name="predicate">A filter predicate.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
+	/// <exception cref="ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> this.WaitForSelectAsync(message, predicate, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait for.</param>
 	/// <param name="predicate">A filter predicate.</param>
-	/// <param name="token">A token that can be used to cancel interactivity. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
+	/// <param name="token">A token that can be used to cancel interactivity. Pass <see cref="CancellationToken.None"/> to wait indefinitely.</param>
+	/// <exception cref="ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 			throw new ArgumentException("Message does not contain any select components.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType is ComponentType.Select && predicate(c), token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with.
 	/// </summary>
 	/// <remarks>This is here for backwards-compatibility and will internally create a cancellation token.</remarks>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 		=> this.WaitForSelectAsync(message, id, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, string id, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 			throw new ArgumentException("Message does not contain any select components.");
 
 		if (message.Components.SelectMany(c => c.Components).OfType<DiscordSelectComponent>().All(c => c.CustomId != id))
 			throw new ArgumentException($"Message does not contain select component with Id of '{id}'.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Select && c.Id == id, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with by a specific user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, DiscordUser user, string id, TimeSpan? timeoutOverride = null)
 		=> this.WaitForSelectAsync(message, user, id, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with by a specific user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
+	/// <exception cref="ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, DiscordUser user, string id, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 			throw new ArgumentException("Message does not contain any select components.");
 
 		if (message.Components.SelectMany(c => c.Components).OfType<DiscordSelectComponent>().All(c => c.CustomId != id))
 			throw new ArgumentException($"Message does not contain select with Id of '{id}'.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Id == id && c.User == user, token)).ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 
 	/// <summary>
 	/// Waits for a specific message.
 	/// </summary>
 	/// <param name="predicate">Predicate to match.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<DiscordMessage>> WaitForMessageAsync(Func<DiscordMessage, bool> predicate,
 		TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasMessageIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No message intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._messageCreatedWaiter.WaitForMatchAsync(new MatchRequest<MessageCreateEventArgs>(x => predicate(x.Message), timeout)).ConfigureAwait(false);
 
 		return new InteractivityResult<DiscordMessage>(returns == null, returns?.Message);
 	}
 
 	/// <summary>
 	/// Wait for a specific reaction.
 	/// </summary>
 	/// <param name="predicate">Predicate to match.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 		TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No reaction intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._messageReactionAddWaiter.WaitForMatchAsync(new MatchRequest<MessageReactionAddEventArgs>(predicate, timeout)).ConfigureAwait(false);
 
 		return new InteractivityResult<MessageReactionAddEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Wait for a specific reaction.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="message">Message reaction was added to.</param>
 	/// <param name="user">User that made the reaction.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(DiscordMessage message, DiscordUser user,
 		TimeSpan? timeoutOverride = null)
 		=> await this.WaitForReactionAsync(x => x.User.Id == user.Id && x.Message.Id == message.Id, timeoutOverride).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for a specific reaction.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="predicate">Predicate to match.</param>
 	/// <param name="message">Message reaction was added to.</param>
 	/// <param name="user">User that made the reaction.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 		DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> await this.WaitForReactionAsync(x => predicate(x) && x.User.Id == user.Id && x.Message.Id == message.Id, timeoutOverride).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for a specific reaction.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="predicate">predicate to match.</param>
 	/// <param name="user">User that made the reaction.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 		DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> await this.WaitForReactionAsync(x => predicate(x) && x.User.Id == user.Id, timeoutOverride).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for a user to start typing.
 	/// </summary>
 	/// <param name="user">User that starts typing.</param>
 	/// <param name="channel">Channel the user is typing in.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(DiscordUser user,
 		DiscordChannel channel, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No typing intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._typingStartWaiter.WaitForMatchAsync(
 			new MatchRequest<TypingStartEventArgs>(x => x.User.Id == user.Id && x.Channel.Id == channel.Id, timeout))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Waits for a user to start typing.
 	/// </summary>
 	/// <param name="user">User that starts typing.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(DiscordUser user, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No typing intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._typingStartWaiter.WaitForMatchAsync(
 			new MatchRequest<TypingStartEventArgs>(x => x.User.Id == user.Id, timeout))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Waits for any user to start typing.
 	/// </summary>
 	/// <param name="channel">Channel to type in.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<TypingStartEventArgs>> WaitForTypingAsync(DiscordChannel channel, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No typing intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._typingStartWaiter.WaitForMatchAsync(
 			new MatchRequest<TypingStartEventArgs>(x => x.Channel.Id == channel.Id, timeout))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Collects reactions on a specific message.
 	/// </summary>
 	/// <param name="m">Message to collect reactions on.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<ReadOnlyCollection<Reaction>> CollectReactionsAsync(DiscordMessage m, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No reaction intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var collection = await this._reactionCollector.CollectAsync(new ReactionCollectRequest(m, timeout)).ConfigureAwait(false);
 
 		return collection;
 	}
 
 	/// <summary>
 	/// Waits for specific event args to be received. Make sure the appropriate <see cref="DiscordIntents"/> are registered, if needed.
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	/// <param name="predicate">The predicate.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<T>> WaitForEventArgsAsync<T>(Func<T, bool> predicate, TimeSpan? timeoutOverride = null) where T : AsyncEventArgs
 	{
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 
 		using var waiter = new EventWaiter<T>(this.Client);
 		var res = await waiter.WaitForMatchAsync(new MatchRequest<T>(predicate, timeout)).ConfigureAwait(false);
 		return new InteractivityResult<T>(res == null, res);
 	}
 
 	/// <summary>
 	/// Collects the event arguments.
 	/// </summary>
 	/// <param name="predicate">The predicate.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<ReadOnlyCollection<T>> CollectEventArgsAsync<T>(Func<T, bool> predicate, TimeSpan? timeoutOverride = null) where T : AsyncEventArgs
 	{
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 
 		using var waiter = new EventWaiter<T>(this.Client);
 		var res = await waiter.CollectMatchesAsync(new CollectRequest<T>(predicate, timeout)).ConfigureAwait(false);
 		return res;
 	}
 
 	/// <summary>
 	/// Sends a paginated message with buttons.
 	/// </summary>
 	/// <param name="channel">The channel to send it on.</param>
 	/// <param name="user">User to give control.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="buttons">Pagination buttons (pass null to use buttons defined in <see cref="InteractivityConfiguration"/>).</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public async Task SendPaginatedMessageAsync(
 		DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons,
 		PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 	{
 		var bhv = behaviour ?? this.Config.PaginationBehaviour;
 		var del = deletion ?? this.Config.ButtonBehavior;
 		var bts = buttons ?? this.Config.PaginationButtons;
 
 		bts = new PaginationButtons(bts);
 		if (bhv is PaginationBehaviour.Ignore)
 		{
 			bts.SkipLeft.Disable();
 			bts.Left.Disable();
 		}
 
 		var builder = new DiscordMessageBuilder()
 			.WithContent(pages.First().Content)
 			.WithEmbed(pages.First().Embed)
 			.AddComponents(bts.ButtonArray);
 
 		var message = await builder.SendAsync(channel).ConfigureAwait(false);
 
 		var req = new ButtonPaginationRequest(message, user, bhv, del, bts, pages, token == default ? this.GetCancellationToken() : token);
 
 		await this._compPaginator.DoPaginationAsync(req).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a paginated message with buttons.
 	/// </summary>
 	/// <param name="channel">The channel to send it on.</param>
 	/// <param name="user">User to give control.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="buttons">Pagination buttons (pass null to use buttons defined in <see cref="InteractivityConfiguration"/>).</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public Task SendPaginatedMessageAsync(
 		DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons, TimeSpan? timeoutOverride,
 		PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 		=> this.SendPaginatedMessageAsync(channel, user, pages, buttons, behaviour, deletion, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Sends the paginated message.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="user">The user.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="behaviour">The behaviour.</param>
 	/// <param name="deletion">The deletion.</param>
 	/// <param name="token">The token.</param>
 	/// <returns>A Task.</returns>
 	public Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 		=> this.SendPaginatedMessageAsync(channel, user, pages, default, behaviour, deletion, token);
 
 	/// <summary>
 	/// Sends the paginated message.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="user">The user.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	/// <param name="behaviour">The behaviour.</param>
 	/// <param name="deletion">The deletion.</param>
 	/// <returns>A Task.</returns>
 	public Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, TimeSpan? timeoutOverride, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 		=> this.SendPaginatedMessageAsync(channel, user, pages, timeoutOverride, behaviour, deletion);
 
 	/// <summary>
 	/// Sends a paginated message.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="channel">Channel to send paginated message in.</param>
 	/// <param name="user">User to give control.</param>
 	/// <param name="pages">Pages.</param>
 	/// <param name="emojis">Pagination emojis.</param>
 	/// <param name="behaviour">Pagination behaviour (when hitting max and min indices).</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationEmojis emojis,
 		PaginationBehaviour? behaviour = default, PaginationDeletion? deletion = default, TimeSpan? timeoutOverride = null)
 	{
 		var builder = new DiscordMessageBuilder()
 			.WithContent(pages.First().Content)
 			.WithEmbed(pages.First().Embed);
 		var m = await builder.SendAsync(channel).ConfigureAwait(false);
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 
 		var bhv = behaviour ?? this.Config.PaginationBehaviour;
 		var del = deletion ?? this.Config.PaginationDeletion;
 		var ems = emojis ?? this.Config.PaginationEmojis;
 
 		var pRequest = new PaginationRequest(m, user, bhv, del, ems, timeout, pages);
 
 		await this._paginator.DoPaginationAsync(pRequest).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a paginated message in response to an interaction.
 	/// <para>
 	/// <b>Pass the interaction directly. Interactivity will ACK it.</b>
 	/// </para>
 	/// </summary>
 	/// <param name="interaction">The interaction to create a response to.</param>
 	/// <param name="deferred">Whether the interaction was deferred.</param>
 	/// <param name="ephemeral">Whether the response should be ephemeral.</param>
 	/// <param name="user">The user to listen for button presses from.</param>
 	/// <param name="pages">The pages to paginate.</param>
 	/// <param name="buttons">Optional: custom buttons.</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public async Task SendPaginatedResponseAsync(DiscordInteraction interaction, bool deferred, bool ephemeral, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons = null, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 	{
 		var bhv = behaviour ?? this.Config.PaginationBehaviour;
 		var del = deletion ?? this.Config.ButtonBehavior;
 		var bts = buttons ?? this.Config.PaginationButtons;
 
 		bts = new PaginationButtons(bts);
 		if (bhv is PaginationBehaviour.Ignore)
 		{
 			bts.SkipLeft.Disable();
 			bts.Left.Disable();
 		}
 
 		DiscordMessage message;
 
 		if (deferred)
 		{
 			var builder = new DiscordWebhookBuilder()
 			.WithContent(pages.First().Content)
 			.AddEmbed(pages.First().Embed)
 			.AddComponents(bts.ButtonArray);
 			message = await interaction.EditOriginalResponseAsync(builder).ConfigureAwait(false);
 		}
 		else
 		{
 			var builder = new DiscordInteractionResponseBuilder()
 			.WithContent(pages.First().Content)
 			.AddEmbed(pages.First().Embed)
 			.AsEphemeral(ephemeral)
 			.AddComponents(bts.ButtonArray);
 			await interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder).ConfigureAwait(false);
 			message = await interaction.GetOriginalResponseAsync().ConfigureAwait(false);
 		}
 
 		var req = new InteractionPaginationRequest(interaction, message, user, bhv, del, bts, pages, token);
 
 		await this._compPaginator.DoPaginationAsync(req).ConfigureAwait(false);
 	}
 
 
 	/// <summary>
 	/// Waits for a custom pagination request to finish.
 	/// This does NOT handle removing emojis after finishing for you.
 	/// </summary>
 	/// <param name="request"></param>
 	/// <returns></returns>
 	public async Task WaitForCustomPaginationAsync(IPaginationRequest request) => await this._paginator.DoPaginationAsync(request).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for custom button-based pagination request to finish.
 	/// <br/>
 	/// This does <i><b>not</b></i> invoke <see cref="DisCatSharp.Interactivity.EventHandling.IPaginationRequest.DoCleanupAsync"/>.
 	/// </summary>
 	/// <param name="request">The request to wait for.</param>
 	public async Task WaitForCustomComponentPaginationAsync(IPaginationRequest request) => await this._compPaginator.DoPaginationAsync(request).ConfigureAwait(false);
 
 	/// <summary>
 	/// Generates pages from a string, and puts them in message content.
 	/// </summary>
 	/// <param name="input">Input string.</param>
 	/// <param name="splitType">How to split input string.</param>
 	/// <returns></returns>
 	public IEnumerable<Page> GeneratePagesInContent(string input, SplitType splitType = SplitType.Character)
 	{
 		if (string.IsNullOrEmpty(input))
 			throw new ArgumentException("You must provide a string that is not null or empty!");
 
 		var result = new List<Page>();
 		List<string> split;
 
 		switch (splitType)
 		{
 			default:
 			case SplitType.Character:
 				split = this.SplitString(input, 500).ToList();
 				break;
 			case SplitType.Line:
 				var subsplit = input.Split('\n');
 
 				split = new List<string>();
 				var s = "";
 
 				for (var i = 0; i < subsplit.Length; i++)
 				{
 					s += subsplit[i];
 					if (i >= 15 && i % 15 == 0)
 					{
 						split.Add(s);
 						s = "";
 					}
 				}
 				if (split.All(x => x != s))
 					split.Add(s);
 				break;
 		}
 
 		var page = 1;
 		foreach (var s in split)
 		{
 			result.Add(new Page($"Page {page}:\n{s}"));
 			page++;
 		}
 
 		return result;
 	}
 
 	/// <summary>
 	/// Generates pages from a string, and puts them in message embeds.
 	/// </summary>
 	/// <param name="input">Input string.</param>
 	/// <param name="splitType">How to split input string.</param>
 	/// <param name="embedBase">Base embed for output embeds.</param>
 	/// <returns></returns>
 	public IEnumerable<Page> GeneratePagesInEmbed(string input, SplitType splitType = SplitType.Character, DiscordEmbedBuilder embedBase = null)
 	{
 		if (string.IsNullOrEmpty(input))
 			throw new ArgumentException("You must provide a string that is not null or empty!");
 
 		var embed = embedBase ?? new DiscordEmbedBuilder();
 
 		var result = new List<Page>();
 		List<string> split;
 
 		switch (splitType)
 		{
 			default:
 			case SplitType.Character:
 				split = this.SplitString(input, 500).ToList();
 				break;
 			case SplitType.Line:
 				var subsplit = input.Split('\n');
 
 				split = new List<string>();
 				var s = "";
 
 				for (var i = 0; i < subsplit.Length; i++)
 				{
 					s += $"{subsplit[i]}\n";
 					if (i % 15 == 0 && i != 0)
 					{
 						split.Add(s);
 						s = "";
 					}
 				}
 				if (!split.Any(x => x == s))
 					split.Add(s);
 				break;
 		}
 
 		var page = 1;
 		foreach (var s in split)
 		{
 			result.Add(new Page("", new DiscordEmbedBuilder(embed).WithDescription(s).WithFooter($"Page {page}/{split.Count}")));
 			page++;
 		}
 
 		return result;
 	}
 
 	/// <summary>
 	/// Splits the string.
 	/// </summary>
 	/// <param name="str">The string.</param>
 	/// <param name="chunkSize">The chunk size.</param>
 	private List<string> SplitString(string str, int chunkSize)
 	{
 		var res = new List<string>();
 		var len = str.Length;
 		var i = 0;
 
 		while (i < len)
 		{
 			var size = Math.Min(len - i, chunkSize);
 			res.Add(str.Substring(i, size));
 			i += size;
 		}
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets the cancellation token.
 	/// </summary>
 	/// <param name="timeout">The timeout.</param>
 	private CancellationToken GetCancellationToken(TimeSpan? timeout = null) => new CancellationTokenSource(timeout ?? this.Config.Timeout).Token;
 
 	/// <summary>
 	/// Handles an invalid interaction.
 	/// </summary>
 	/// <param name="interaction">The interaction.</param>
 	private async Task HandleInvalidInteraction(DiscordInteraction interaction)
 	{
 		var at = this.Config.ResponseBehavior switch
 		{
 			InteractionResponseBehavior.Ack => interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate),
 			InteractionResponseBehavior.Respond => interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder { Content = this.Config.ResponseMessage, IsEphemeral = true}),
 			InteractionResponseBehavior.Ignore => Task.CompletedTask,
 			_ => throw new ArgumentException("Unknown enum value.")
 		};
 
 		await at;
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkExtension.cs b/DisCatSharp.Lavalink/LavalinkExtension.cs
index 9aa3231dd..7f2159754 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="System.InvalidOperationException"/>
+	/// <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];
 
 		var con = new LavalinkNodeConnection(this.Client, this, config);
 		con.NodeDisconnected += this.Con_NodeDisconnected;
 		con.Disconnected += this.Con_Disconnected;
 		this._connectedNodes[con.NodeEndpoint] = con;
 		try
 		{
 			await con.StartAsync().ConfigureAwait(false);
 		}
 		catch
 		{
 			this.Con_NodeDisconnected(con);
 			throw;
 		}
 
 		return con;
 	}
 
 	/// <summary>
 	/// Gets the Lavalink node connection for the specified endpoint.
 	/// </summary>
 	/// <param name="endpoint">Endpoint at which the node resides.</param>
 	/// <returns>Lavalink node connection.</returns>
 	public LavalinkNodeConnection GetNodeConnection(ConnectionEndpoint endpoint)
 		=> this._connectedNodes.ContainsKey(endpoint) ? this._connectedNodes[endpoint] : null;
 
 	/// <summary>
 	/// Gets a Lavalink node connection based on load balancing and an optional voice region.
 	/// </summary>
 	/// <param name="region">The region to compare with the node's <see cref="LavalinkConfiguration.Region"/>, if any.</param>
 	/// <returns>The least load affected node connection, or null if no nodes are present.</returns>
 	public LavalinkNodeConnection GetIdealNodeConnection(DiscordVoiceRegion region = null)
 	{
 		if (this._connectedNodes.Count <= 1)
 			return this._connectedNodes.Values.FirstOrDefault();
 
 		var nodes = this._connectedNodes.Values.ToArray();
 
 		if (region != null)
 		{
 			var regionPredicate = new Func<LavalinkNodeConnection, bool>(x => x.Region == region);
 
 			if (nodes.Any(regionPredicate))
 				nodes = nodes.Where(regionPredicate).ToArray();
 
 			if (nodes.Length <= 1)
 				return nodes.FirstOrDefault();
 		}
 
 		return this.FilterByLoad(nodes);
 	}
 
 	/// <summary>
 	/// Gets a Lavalink guild connection from a <see cref="DisCatSharp.Entities.DiscordGuild"/>.
 	/// </summary>
 	/// <param name="guild">The guild the connection is on.</param>
 	/// <returns>The found guild connection, or null if one could not be found.</returns>
 	public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 	{
 		var nodes = this._connectedNodes.Values;
 		var node = nodes.FirstOrDefault(x => x.ConnectedGuildsInternal.ContainsKey(guild.Id));
 		return node?.GetGuildConnection(guild);
 	}
 
 	/// <summary>
 	/// Filters the by load.
 	/// </summary>
 	/// <param name="nodes">The nodes.</param>
 	private LavalinkNodeConnection FilterByLoad(LavalinkNodeConnection[] nodes)
 	{
 		Array.Sort(nodes, (a, b) =>
 		{
 			if (!a.Statistics.Updated || !b.Statistics.Updated)
 				return 0;
 
 			//https://github.com/FredBoat/Lavalink-Client/blob/48bc27784f57be5b95d2ff2eff6665451b9366f5/src/main/java/lavalink/client/io/LavalinkLoadBalancer.java#L122
 			//https://github.com/briantanner/eris-lavalink/blob/master/src/PlayerManager.js#L329
 
 			//player count
 			var aPenaltyCount = a.Statistics.ActivePlayers;
 			var bPenaltyCount = b.Statistics.ActivePlayers;
 
 			//cpu load
 			aPenaltyCount += (int)Math.Pow(1.05d, (100 * (a.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 			bPenaltyCount += (int)Math.Pow(1.05d, (100 * (b.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 
 			//frame load
 			if (a.Statistics.AverageDeficitFramesPerMinute > 0)
 			{
 				//deficit frame load
 				aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 				//null frame load
 				aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 			}
 
 			//frame load
 			if (b.Statistics.AverageDeficitFramesPerMinute > 0)
 			{
 				//deficit frame load
 				bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 				//null frame load
 				bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 			}
 
 			return aPenaltyCount - bPenaltyCount;
 		});
 
 		return nodes[0];
 	}
 
 	/// <summary>
 	/// Removes a node.
 	/// </summary>
 	/// <param name="node">The node to be removed.</param>
 	private void Con_NodeDisconnected(LavalinkNodeConnection node)
 		=> this._connectedNodes.TryRemove(node.NodeEndpoint, out _);
 
 	/// <summary>
 	/// Disconnects a node.
 	/// </summary>
 	/// <param name="node">The affected node.</param>
 	/// <param name="e">The node disconnected event args.</param>
 	private Task Con_Disconnected(LavalinkNodeConnection node, NodeDisconnectedEventArgs e)
 		=> this._nodeDisconnected.InvokeAsync(node, e);
 }
diff --git a/DisCatSharp.VoiceNext/StreamExtensions.cs b/DisCatSharp.VoiceNext/StreamExtensions.cs
index 7f7357bc2..7c0c62b11 100644
--- a/DisCatSharp.VoiceNext/StreamExtensions.cs
+++ b/DisCatSharp.VoiceNext/StreamExtensions.cs
@@ -1,71 +1,71 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Buffers;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.VoiceNext;
 
 /// <summary>
 /// The stream extensions.
 /// </summary>
 public static class StreamExtensions
 {
 	/// <summary>
 	/// Asynchronously reads the bytes from the current stream and writes them to the specified <see cref="VoiceTransmitSink"/>.
 	/// </summary>
-	/// <param name="source">The source <see cref="System.IO.Stream"/></param>
+	/// <param name="source">The source <see cref="Stream"/></param>
 	/// <param name="destination">The target <see cref="VoiceTransmitSink"/></param>
 	/// <param name="bufferSize">The size, in bytes, of the buffer. This value must be greater than zero. If <see langword="null"/>, defaults to the packet size specified by <paramref name="destination"/>.</param>
 	/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
 	/// <returns></returns>
 	public static async Task CopyToAsync(this Stream source, VoiceTransmitSink destination, int? bufferSize = null, CancellationToken cancellationToken = default)
 	{
 		// adapted from CoreFX
 		// https://source.dot.net/#System.Private.CoreLib/Stream.cs,8048a9680abdd13b
 
 		if (source is null)
 			throw new ArgumentNullException(nameof(source));
 		if (destination is null)
 			throw new ArgumentNullException(nameof(destination));
 		if (bufferSize != null && bufferSize <= 0)
 			throw new ArgumentOutOfRangeException(nameof(bufferSize), bufferSize, "bufferSize cannot be less than or equal to zero");
 
 		var bufferLength = bufferSize ?? destination.SampleLength;
 		var buffer = ArrayPool<byte>.Shared.Rent(bufferLength);
 		try
 		{
 			int bytesRead;
 			while ((bytesRead = await source.ReadAsync(buffer.AsMemory(0, bufferLength), cancellationToken).ConfigureAwait(false)) != 0)
 			{
 				await destination.WriteAsync(new ReadOnlyMemory<byte>(buffer, 0, bytesRead), cancellationToken).ConfigureAwait(false);
 			}
 		}
 		finally
 		{
 			ArrayPool<byte>.Shared.Return(buffer);
 		}
 	}
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextExtension.cs b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
index fc7f47b3f..3ab318245 100644
--- a/DisCatSharp.VoiceNext/VoiceNextExtension.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
@@ -1,265 +1,265 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.VoiceNext.Entities;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.VoiceNext;
 
 /// <summary>
 /// Represents VoiceNext extension, which acts as Discord voice client.
 /// </summary>
 public sealed class VoiceNextExtension : BaseExtension
 {
 	/// <summary>
 	/// Gets or sets the configuration.
 	/// </summary>
 	private readonly VoiceNextConfiguration _configuration;
 
 	/// <summary>
 	/// Gets or sets the active connections.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, VoiceNextConnection> _activeConnections;
 
 	/// <summary>
 	/// Gets or sets the voice state updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> _voiceStateUpdates;
 
 	/// <summary>
 	/// Gets or sets the voice server updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> _voiceServerUpdates;
 
 	/// <summary>
 	/// Gets whether this connection has incoming voice enabled.
 	/// </summary>
 	public bool IsIncomingEnabled { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="VoiceNextExtension"/> class.
 	/// </summary>
 	/// <param name="config">The config.</param>
 	internal VoiceNextExtension(VoiceNextConfiguration config)
 	{
 		this._configuration = new VoiceNextConfiguration(config);
 		this.IsIncomingEnabled = config.EnableIncoming;
 
 		this._activeConnections = new ConcurrentDictionary<ulong, VoiceNextConnection>();
 		this._voiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
 		this._voiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
 	}
 
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
-	/// <exception cref="System.InvalidOperationException"/>
+	/// <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;
 
 	/// <summary>
 	/// Vnc_S the voice disconnected.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <returns>A Task.</returns>
 	private async Task Vnc_VoiceDisconnected(DiscordGuild guild)
 	{
 		VoiceNextConnection vnc = null;
 		if (this._activeConnections.ContainsKey(guild.Id))
 			this._activeConnections.TryRemove(guild.Id, out vnc);
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = guild.Id,
 				ChannelId = null
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (guild.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Client_S the voice state update.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private Task Client_VoiceStateUpdate(DiscordClient client, VoiceStateUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (e.User == null)
 			return Task.CompletedTask;
 
 		if (e.User.Id == this.Client.CurrentUser.Id)
 		{
 			if (e.After.Channel == null && this._activeConnections.TryRemove(gld.Id, out var ac))
 				ac.Disconnect();
 
 			if (this._activeConnections.TryGetValue(e.Guild.Id, out var vnc))
 				vnc.TargetChannel = e.Channel;
 
 			if (!string.IsNullOrWhiteSpace(e.SessionId) && e.Channel != null && this._voiceStateUpdates.TryRemove(gld.Id, out var xe))
 				xe.SetResult(e);
 		}
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Client_S the voice server update.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private async Task Client_VoiceServerUpdate(DiscordClient client, VoiceServerUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return;
 
 		if (this._activeConnections.TryGetValue(e.Guild.Id, out var vnc))
 		{
 			vnc.ServerData = new VoiceServerUpdatePayload
 			{
 				Endpoint = e.Endpoint,
 				GuildId = e.Guild.Id,
 				Token = e.VoiceToken
 			};
 
 			var eps = e.Endpoint;
 			var epi = eps.LastIndexOf(':');
 			var eph = string.Empty;
 			var epp = 443;
 			if (epi != -1)
 			{
 				eph = eps[..epi];
 				epp = int.Parse(eps[(epi + 1)..]);
 			}
 			else
 			{
 				eph = eps;
 			}
 			vnc.WebSocketEndpoint = new ConnectionEndpoint { Hostname = eph, Port = epp };
 
 			vnc.Resume = false;
 			await vnc.ReconnectAsync().ConfigureAwait(false);
 		}
 
 		if (this._voiceServerUpdates.ContainsKey(gld.Id))
 		{
 			this._voiceServerUpdates.TryRemove(gld.Id, out var xe);
 			xe.SetResult(e);
 		}
 	}
 }
diff --git a/DisCatSharp/Clients/BaseDiscordClient.cs b/DisCatSharp/Clients/BaseDiscordClient.cs
index d223c1b6e..77a35bc46 100644
--- a/DisCatSharp/Clients/BaseDiscordClient.cs
+++ b/DisCatSharp/Clients/BaseDiscordClient.cs
@@ -1,321 +1,321 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Net;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents a common base for various Discord Client implementations.
 /// </summary>
 public abstract class BaseDiscordClient : IDisposable
 {
 	/// <summary>
 	/// Gets the api client.
 	/// </summary>
 	internal protected DiscordApiClient ApiClient { get; }
 
 	/// <summary>
 	/// Gets the configuration.
 	/// </summary>
 	internal protected DiscordConfiguration Configuration { get; }
 
 	/// <summary>
 	/// Gets the instance of the logger for this client.
 	/// </summary>
 	public ILogger<BaseDiscordClient> Logger { get; internal set; }
 
 	/// <summary>
 	/// Gets the string representing the version of bot lib.
 	/// </summary>
 	public string VersionString { get; }
 
 	/// <summary>
 	/// Gets the bot library name.
 	/// </summary>
 	public string BotLibrary { get; }
 
 	[Obsolete("Use GetLibraryDeveloperTeamAsync")]
 	public DisCatSharpTeam LibraryDeveloperTeamAsync
 		=> this.GetLibraryDevelopmentTeamAsync().Result;
 
 	/// <summary>
 	/// Gets the current user.
 	/// </summary>
 	public DiscordUser CurrentUser { get; internal set; }
 
 	/// <summary>
 	/// Gets the current application.
 	/// </summary>
 	public DiscordApplication CurrentApplication { get; internal set; }
 
 	/// <summary>
-	/// Exposes a <see cref="System.Net.Http.HttpClient">Http Client</see> for custom operations.
+	/// Exposes a <see cref="HttpClient">Http Client</see> for custom operations.
 	/// </summary>
 	public HttpClient RestClient { get; internal set; }
 
 	/// <summary>
 	/// Gets the cached guilds for this client.
 	/// </summary>
 	public abstract IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 
 	/// <summary>
 	/// Gets the cached users for this client.
 	/// </summary>
 	public ConcurrentDictionary<ulong, DiscordUser> UserCache { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the service provider.</para>
 	/// <para>This allows passing data around without resorting to static members.</para>
 	/// <para>Defaults to null.</para>
 	/// </summary>
 	internal IServiceProvider ServiceProvider { get; set; }
 
 	/// <summary>
 	/// Gets the list of available voice regions. Note that this property will not contain VIP voice regions.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordVoiceRegion> VoiceRegions
 		=> this.VoiceRegionsLazy.Value;
 
 	/// <summary>
 	/// Gets the list of available voice regions. This property is meant as a way to modify <see cref="VoiceRegions"/>.
 	/// </summary>
 	protected internal ConcurrentDictionary<string, DiscordVoiceRegion> InternalVoiceRegions { get; set; }
 	internal Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> VoiceRegionsLazy;
 
 	/// <summary>
 	/// Initializes this Discord API client.
 	/// </summary>
 	/// <param name="config">Configuration for this client.</param>
 	protected BaseDiscordClient(DiscordConfiguration config)
 	{
 		this.Configuration = new DiscordConfiguration(config);
 		this.ServiceProvider = config.ServiceProvider;
 
 		if (this.ServiceProvider != null)
 		{
 			this.Configuration.LoggerFactory ??= config.ServiceProvider.GetService<ILoggerFactory>();
 			this.Logger = config.ServiceProvider.GetService<ILogger<BaseDiscordClient>>();
 		}
 
 		if (this.Configuration.LoggerFactory == null)
 		{
 			this.Configuration.LoggerFactory = new DefaultLoggerFactory();
 			this.Configuration.LoggerFactory.AddProvider(new DefaultLoggerProvider(this));
 		}
 		this.Logger ??= this.Configuration.LoggerFactory.CreateLogger<BaseDiscordClient>();
 
 		this.ApiClient = new DiscordApiClient(this);
 		this.UserCache = new ConcurrentDictionary<ulong, DiscordUser>();
 		this.InternalVoiceRegions = new ConcurrentDictionary<string, DiscordVoiceRegion>();
 		this.VoiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(this.InternalVoiceRegions));
 
 		this.RestClient = new();
 		this.RestClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 		this.RestClient.DefaultRequestHeaders.TryAddWithoutValidation("X-Discord-Locale", this.Configuration.Locale);
 
 		var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
 		var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (iv != null)
 		{
 			this.VersionString = iv.InformationalVersion;
 		}
 		else
 		{
 			var v = a.GetName().Version;
 			var vs = v.ToString(3);
 
 			if (v.Revision > 0)
 				this.VersionString = $"{vs}, CI build {v.Revision}";
 		}
 
 		this.BotLibrary = "DisCatSharp";
 	}
 
 	/// <summary>
 	/// Gets the current API application.
 	/// </summary>
 	public async Task<DiscordApplication> GetCurrentApplicationAsync()
 	{
 		var tapp = await this.ApiClient.GetCurrentApplicationInfoAsync().ConfigureAwait(false);
 		var app = new DiscordApplication
 		{
 			Discord = this,
 			Id = tapp.Id,
 			Name = tapp.Name,
 			Description = tapp.Description,
 			Summary = tapp.Summary,
 			IconHash = tapp.IconHash,
 			RpcOrigins = tapp.RpcOrigins != null ? new ReadOnlyCollection<string>(tapp.RpcOrigins) : null,
 			Flags = tapp.Flags,
 			RequiresCodeGrant = tapp.BotRequiresCodeGrant,
 			IsPublic = tapp.IsPublicBot,
 			IsHook = tapp.IsHook,
 			Type = tapp.Type,
 			PrivacyPolicyUrl = tapp.PrivacyPolicyUrl,
 			TermsOfServiceUrl = tapp.TermsOfServiceUrl,
 			CustomInstallUrl = tapp.CustomInstallUrl,
 			InstallParams = tapp.InstallParams,
 			Tags = (tapp.Tags ?? Enumerable.Empty<string>()).ToArray()
 		};
 
 		if (tapp.Team == null)
 		{
 			app.Owners = new ReadOnlyCollection<DiscordUser>(new[] { new DiscordUser(tapp.Owner) });
 			app.Team = null;
 			app.TeamName = null;
 		}
 		else
 		{
 			app.Team = new DiscordTeam(tapp.Team);
 
 			var members = tapp.Team.Members
 				.Select(x => new DiscordTeamMember(x) { TeamId = app.Team.Id, TeamName = app.Team.Name, User = new DiscordUser(x.User) })
 				.ToArray();
 
 			var owners = members
 				.Where(x => x.MembershipStatus == DiscordTeamMembershipStatus.Accepted)
 				.Select(x => x.User)
 				.ToArray();
 
 			app.Owners = new ReadOnlyCollection<DiscordUser>(owners);
 			app.Team.Owner = owners.FirstOrDefault(x => x.Id == tapp.Team.OwnerId);
 			app.Team.Members = new ReadOnlyCollection<DiscordTeamMember>(members);
 			app.TeamName = app.Team.Name;
 		}
 
 		app.GuildId = tapp.GuildId.ValueOrDefault();
 		app.Slug = tapp.Slug.ValueOrDefault();
 		app.PrimarySkuId = tapp.PrimarySkuId.ValueOrDefault();
 		app.VerifyKey = tapp.VerifyKey.ValueOrDefault();
 		app.CoverImageHash = tapp.CoverImageHash.ValueOrDefault();
 
 		return app;
 	}
 
 	/// <summary>
 	/// Gets a list of voice regions.
 	/// </summary>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 		=> this.ApiClient.ListVoiceRegionsAsync();
 
 	/// <summary>
 	/// Initializes this client. This method fetches information about current user, application, and voice regions.
 	/// </summary>
 	public virtual async Task InitializeAsync()
 	{
 		if (this.CurrentUser == null)
 		{
 			this.CurrentUser = await this.ApiClient.GetCurrentUserAsync().ConfigureAwait(false);
 			this.UserCache.AddOrUpdate(this.CurrentUser.Id, this.CurrentUser, (id, xu) => this.CurrentUser);
 		}
 
 		if (this.Configuration.TokenType == TokenType.Bot && this.CurrentApplication == null)
 			this.CurrentApplication = await this.GetCurrentApplicationAsync().ConfigureAwait(false);
 
 		if (this.Configuration.TokenType != TokenType.Bearer && this.InternalVoiceRegions.IsEmpty)
 		{
 			var vrs = await this.ListVoiceRegionsAsync().ConfigureAwait(false);
 			foreach (var xvr in vrs)
 				this.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 		}
 	}
 
 	/// <summary>
 	/// Gets the current gateway info for the provided token.
 	/// <para>If no value is provided, the configuration value will be used instead.</para>
 	/// </summary>
 	/// <returns>A gateway info object.</returns>
 	public async Task<GatewayInfo> GetGatewayInfoAsync(string token = null)
 	{
 		if (this.Configuration.TokenType != TokenType.Bot)
 			throw new InvalidOperationException("Only bot tokens can access this info.");
 
 		if (string.IsNullOrEmpty(this.Configuration.Token))
 		{
 			if (string.IsNullOrEmpty(token))
 				throw new InvalidOperationException("Could not locate a valid token.");
 
 			this.Configuration.Token = token;
 
 			var res = await this.ApiClient.GetGatewayInfoAsync().ConfigureAwait(false);
 			this.Configuration.Token = null;
 			return res;
 		}
 
 		return await this.ApiClient.GetGatewayInfoAsync().ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets some information about the development team behind DisCatSharp.
 	/// Can be used for crediting etc.
 	/// <para>Note: This call contacts servers managed by the DCS team, no information is collected.</para>
 	/// <returns>The team, or null with errors being logged on failure.</returns>
 	/// </summary>
 	public async Task<DisCatSharpTeam> GetLibraryDevelopmentTeamAsync()
 		=> await DisCatSharpTeam.Get(this.RestClient, this.Logger, this.ApiClient).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets a cached user.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	internal DiscordUser GetCachedOrEmptyUserInternal(ulong userId)
 	{
 		this.TryGetCachedUserInternal(userId, out var user);
 		return user;
 	}
 
 	/// <summary>
 	/// Tries the get a cached user.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="user">The user.</param>
 	internal bool TryGetCachedUserInternal(ulong userId, out DiscordUser user)
 	{
 		if (this.UserCache.TryGetValue(userId, out user))
 			return true;
 
 		user = new DiscordUser { Id = userId, Discord = this };
 		return false;
 	}
 
 	/// <summary>
 	/// Disposes this client.
 	/// </summary>
 	public abstract void Dispose();
 }
diff --git a/DisCatSharp/Clients/DiscordClient.cs b/DisCatSharp/Clients/DiscordClient.cs
index c6ab4654d..739119e5b 100644
--- a/DisCatSharp/Clients/DiscordClient.cs
+++ b/DisCatSharp/Clients/DiscordClient.cs
@@ -1,1333 +1,1333 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A Discord API wrapper.
 /// </summary>
 public sealed partial class DiscordClient : BaseDiscordClient
 {
 	#region Internal Fields/Properties
 
 	internal bool IsShard = false;
 	/// <summary>
 	/// Gets the message cache.
 	/// </summary>
 	internal RingBuffer<DiscordMessage> MessageCache { get; }
 
 	private List<BaseExtension> _extensions = new();
 	private StatusUpdate _status;
 
 	/// <summary>
 	/// Gets the connection lock.
 	/// </summary>
 	private readonly ManualResetEventSlim _connectionLock = new(true);
 
 	#endregion
 
 	#region Public Fields/Properties
 	/// <summary>
 	/// Gets the gateway protocol version.
 	/// </summary>
 	public int GatewayVersion { get; internal set; }
 
 	/// <summary>
 	/// Gets the gateway session information for this client.
 	/// </summary>
 	public GatewayInfo GatewayInfo { get; internal set; }
 
 	/// <summary>
 	/// Gets the gateway URL.
 	/// </summary>
 	public Uri GatewayUri { get; internal set; }
 
 	/// <summary>
 	/// Gets the total number of shards the bot is connected to.
 	/// </summary>
 	public int ShardCount => this.GatewayInfo != null
 		? this.GatewayInfo.ShardCount
 		: this.Configuration.ShardCount;
 
 	/// <summary>
 	/// Gets the currently connected shard ID.
 	/// </summary>
 	public int ShardId
 		=> this.Configuration.ShardId;
 
 	/// <summary>
 	/// Gets the intents configured for this client.
 	/// </summary>
 	public DiscordIntents Intents
 		=> this.Configuration.Intents;
 
 	/// <summary>
 	/// Gets a dictionary of guilds that this client is in. The dictionary's key is the guild ID. Note that the
 	/// guild objects in this dictionary will not be filled in if the specific guilds aren't available (the
 	/// <see cref="GuildAvailable"/> or <see cref="GuildDownloadCompleted"/> events haven't been fired yet)
 	/// </summary>
 	public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 	internal ConcurrentDictionary<ulong, DiscordGuild> GuildsInternal = new();
 
 	/// <summary>
 	/// Gets the websocket latency for this client.
 	/// </summary>
 	public int Ping
 		=> Volatile.Read(ref this._ping);
 
 	private int _ping;
 
 	/// <summary>
 	/// Gets the collection of presences held by this client.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, DiscordPresence> Presences
 		=> this._presencesLazy.Value;
 
 	internal Dictionary<ulong, DiscordPresence> PresencesInternal = new();
 	private Lazy<IReadOnlyDictionary<ulong, DiscordPresence>> _presencesLazy;
 
 	/// <summary>
 	/// Gets the collection of presences held by this client.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordActivity> EmbeddedActivities
 		=> this._embeddedActivitiesLazy.Value;
 
 	internal Dictionary<string, DiscordActivity> EmbeddedActivitiesInternal = new();
 	private Lazy<IReadOnlyDictionary<string, DiscordActivity>> _embeddedActivitiesLazy;
 	#endregion
 
 	#region Constructor/Internal Setup
 
 	/// <summary>
 	/// Initializes a new instance of <see cref="DiscordClient"/>.
 	/// </summary>
 	/// <param name="config">Specifies configuration parameters.</param>
 	public DiscordClient(DiscordConfiguration config)
 		: base(config)
 	{
 		if (this.Configuration.MessageCacheSize > 0)
 		{
 			var intents = this.Configuration.Intents;
 			this.MessageCache = intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages)
 					? new RingBuffer<DiscordMessage>(this.Configuration.MessageCacheSize)
 					: null;
 		}
 
 		this.InternalSetup();
 
 		this.Guilds = new ReadOnlyConcurrentDictionary<ulong, DiscordGuild>(this.GuildsInternal);
 	}
 
 	/// <summary>
 	/// Internal setup of the Client.
 	/// </summary>
 	internal void InternalSetup()
 	{
 		this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", EventExecutionLimit, this.Goof);
 		this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", EventExecutionLimit, this.Goof);
 		this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", EventExecutionLimit, this.EventErrorHandler);
 		this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", EventExecutionLimit, this.EventErrorHandler);
 		this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", EventExecutionLimit, this.EventErrorHandler);
 		this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 		this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 		this._guildDownloadCompletedEv = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", EventExecutionLimit, this.EventErrorHandler);
 		this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADD", EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADD", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageAcknowledged = new AsyncEvent<DiscordClient, MessageAcknowledgeEventArgs>("MESSAGE_ACKNOWLEDGED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messagesBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 		this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 		this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", EventExecutionLimit, this.EventErrorHandler);
 		this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMembersChunked = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", EventExecutionLimit, this.EventErrorHandler);
 		this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", EventExecutionLimit, this.EventErrorHandler);
 		this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", EventExecutionLimit, this.EventErrorHandler);
 		this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutAdded = new AsyncEvent<DiscordClient, GuildMemberTimeoutAddEventArgs>("GUILD_MEMBER_TIMEOUT_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutChanged = new AsyncEvent<DiscordClient, GuildMemberTimeoutUpdateEventArgs>("GUILD_MEMBER_TIMEOUT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutRemoved = new AsyncEvent<DiscordClient, GuildMemberTimeoutRemoveEventArgs>("GUILD_MEMBER_TIMEOUT_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._rateLimitHit = new AsyncEvent<DiscordClient, RateLimitExceptionEventArgs>("RATELIMIT_HIT", EventExecutionLimit, this.EventErrorHandler);
 
 		this.GuildsInternal.Clear();
 
 		this._presencesLazy = new Lazy<IReadOnlyDictionary<ulong, DiscordPresence>>(() => new ReadOnlyDictionary<ulong, DiscordPresence>(this.PresencesInternal));
 		this._embeddedActivitiesLazy = new Lazy<IReadOnlyDictionary<string, DiscordActivity>>(() => new ReadOnlyDictionary<string, DiscordActivity>(this.EmbeddedActivitiesInternal));
 	}
 
 	#endregion
 
 	#region Client Extension Methods
 
 	/// <summary>
 	/// Registers an extension with this client.
 	/// </summary>
 	/// <param name="ext">Extension to register.</param>
 	public void AddExtension(BaseExtension ext)
 	{
 		ext.Setup(this);
 		this._extensions.Add(ext);
 	}
 
 	/// <summary>
 	/// Retrieves a previously registered extension from this client.
 	/// </summary>
 	/// <typeparam name="T">The type of extension to retrieve.</typeparam>
 	/// <returns>The requested extension.</returns>
 	public T GetExtension<T>() where T : BaseExtension
 		=> this._extensions.FirstOrDefault(x => x.GetType() == typeof(T)) as T;
 
 	#endregion
 
 	#region Public Connection Methods
 
 	/// <summary>
 	/// Connects to the gateway.
 	/// </summary>
 	/// <param name="activity">The activity to set. Defaults to null.</param>
 	/// <param name="status">The optional status to set. Defaults to null.</param>
 	/// <param name="idlesince">Since when is the client performing the specified activity. Defaults to null.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when an invalid token was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when an invalid token was provided.</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 ConnectAsync(DiscordActivity activity = null, UserStatus? status = null, DateTimeOffset? idlesince = null)
 	{
 		// Check if connection lock is already set, and set it if it isn't
 		if (!this._connectionLock.Wait(0))
 			throw new InvalidOperationException("This client is already connected.");
 		this._connectionLock.Set();
 
 		var w = 7500;
 		var i = 5;
 		var s = false;
 		Exception cex = null;
 
 		if (activity == null && status == null && idlesince == null)
 			this._status = null;
 		else
 		{
 			var sinceUnix = idlesince != null ? (long?)Utilities.GetUnixTime(idlesince.Value) : null;
 			this._status = new StatusUpdate()
 			{
 				Activity = new TransportActivity(activity),
 				Status = status ?? UserStatus.Online,
 				IdleSince = sinceUnix,
 				IsAfk = idlesince != null,
 				ActivityInternal = activity
 			};
 		}
 
 		if (!this.IsShard)
 		{
 			if (this.Configuration.TokenType != TokenType.Bot)
 				this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 			this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this.BotLibrary, this.VersionString);
 		}
 
 		while (i-- > 0 || this.Configuration.ReconnectIndefinitely)
 		{
 			try
 			{
 				await this.InternalConnectAsync().ConfigureAwait(false);
 				s = true;
 				break;
 			}
 			catch (UnauthorizedException e)
 			{
 				FailConnection(this._connectionLock);
 				throw new Exception("Authentication failed. Check your token and try again.", e);
 			}
 			catch (PlatformNotSupportedException)
 			{
 				FailConnection(this._connectionLock);
 				throw;
 			}
 			catch (NotImplementedException)
 			{
 				FailConnection(this._connectionLock);
 				throw;
 			}
 			catch (Exception ex)
 			{
 				FailConnection(null);
 
 				cex = ex;
 				if (i <= 0 && !this.Configuration.ReconnectIndefinitely) break;
 
 				this.Logger.LogError(LoggerEvents.ConnectionFailure, ex, "Connection attempt failed, retrying in {0}s", w / 1000);
 				await Task.Delay(w).ConfigureAwait(false);
 
 				if (i > 0)
 					w *= 2;
 			}
 		}
 
 		if (!s && cex != null)
 		{
 			this._connectionLock.Set();
 			throw new Exception("Could not connect to Discord.", cex);
 		}
 
 		// non-closure, hence args
 		static void FailConnection(ManualResetEventSlim cl) =>
 			// unlock this (if applicable) so we can let others attempt to connect
 			cl?.Set();
 	}
 
 	/// <summary>
 	/// Reconnects to the gateway.
 	/// </summary>
 	/// <param name="startNewSession">Whether to start a new session.</param>
 	public Task ReconnectAsync(bool startNewSession = true)
 		=> this.InternalReconnectAsync(startNewSession, code: startNewSession ? 1000 : 4002);
 
 	/// <summary>
 	/// Disconnects from the gateway.
 	/// </summary>
 	public async Task DisconnectAsync()
 	{
 		this.Configuration.AutoReconnect = false;
 		if (this.WebSocketClient != null)
 			await this.WebSocketClient.DisconnectAsync().ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Public REST Methods
 
 	/// <summary>
 	/// Gets a user.
 	/// </summary>
 	/// <param name="userId">Id of the user</param>
 	/// <param name="fetch">Whether to fetch the user again. Defaults to true.</param>
 	/// <returns>The requested user.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<DiscordUser> GetUserAsync(ulong userId, bool fetch = true)
 	{
 		if (!fetch)
 		{
 			return this.TryGetCachedUserInternal(userId, out var usr) ? usr : new DiscordUser { Id = userId, Discord = this };
 		}
 		else
 		{
 			var usr = await this.ApiClient.GetUserAsync(userId).ConfigureAwait(false);
 			usr = this.UserCache.AddOrUpdate(userId, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				old.BannerHash = usr.BannerHash;
 				old.BannerColorInternal = usr.BannerColorInternal;
 				old.AvatarDecorationHash = usr.AvatarDecorationHash;
 				old.ThemeColorsInternal = usr.ThemeColorsInternal;
 				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 
 			return usr;
 		}
 	}
 
 	/// <summary>
 	/// Removes all global application commands.
 	/// </summary>
 	public async Task RemoveGlobalApplicationCommandsAsync()
 		=> await this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, Array.Empty<DiscordApplicationCommand>());
 
 	/// <summary>
 	/// Removes all global application commands for a specific guild id.
 	/// </summary>
-	/// <param name="guildId">The target guild id.</param> 
+	/// <param name="guildId">The target guild id.</param>
 	public async Task RemoveGuildApplicationCommandsAsync(ulong guildId)
 		=> await this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, Array.Empty<DiscordApplicationCommand>());
 
 	/// <summary>
 	/// Removes all global application commands for a specific guild.
 	/// </summary>
-	/// <param name="guild">The target guild.</param> 
+	/// <param name="guild">The target guild.</param>
 	public async Task RemoveGuildApplicationCommandsAsync(DiscordGuild guild)
 		=> await this.RemoveGuildApplicationCommandsAsync(guild.Id);
 
 	/// <summary>
 	/// Gets a channel.
 	/// </summary>
 	/// <param name="id">The id of the channel to get.</param>
 	/// <returns>The requested channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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> GetChannelAsync(ulong id)
 		=> this.InternalGetCachedChannel(id) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets a thread.
 	/// </summary>
 	/// <param name="id">The id of the thread to get.</param>
 	/// <returns>The requested thread.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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<DiscordThreadChannel> GetThreadAsync(ulong id)
 		=> this.InternalGetCachedThread(id) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends a normal message.
 	/// </summary>
 	/// <param name="channel">The channel to send to.</param>
 	/// <param name="content">The message content to send.</param>
 	/// <returns>The message that was sent.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> 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<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, content, embeds: null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with an embed.
 	/// </summary>
 	/// <param name="channel">The channel to send to.</param>
 	/// <param name="embed">The embed to attach to the message.</param>
 	/// <returns>The message that was sent.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> 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<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordEmbed embed)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with content and an embed.
 	/// </summary>
 	/// <param name="channel">Channel to send to.</param>
 	/// <param name="content">The message content to send.</param>
 	/// <param name="embed">The embed to attach to the message.</param>
 	/// <returns>The message that was sent.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> 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<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content, DiscordEmbed embed)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with the <see cref="DisCatSharp.Entities.DiscordMessageBuilder"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="builder">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
+	/// <exception cref="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(DiscordChannel channel, DiscordMessageBuilder builder)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
 	/// <summary>
-	/// Sends a message with an <see cref="System.Action{DiscordMessageBuilder}"/>.
+	/// Sends a message with an <see cref="Action{DiscordMessageBuilder}"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="action">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
+	/// <exception cref="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(DiscordChannel channel, Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 		return this.ApiClient.CreateMessageAsync(channel.Id, builder);
 	}
 
 	/// <summary>
 	/// Creates a guild. This requires the bot to be in less than 10 guilds total.
 	/// </summary>
 	/// <param name="name">Name of the guild.</param>
 	/// <param name="region">Voice region of the guild.</param>
 	/// <param name="icon">Stream containing the icon for the guild.</param>
 	/// <param name="verificationLevel">Verification level for the guild.</param>
 	/// <param name="defaultMessageNotifications">Default message notification settings for the guild.</param>
 	/// <param name="systemChannelFlags">System channel flags for the guild.</param>
 	/// <returns>The created guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<DiscordGuild> CreateGuildAsync(string name, string region = null, Optional<Stream> icon = default, VerificationLevel? verificationLevel = null,
 		DefaultMessageNotifications? defaultMessageNotifications = null, SystemChannelFlags? systemChannelFlags = null)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		return this.ApiClient.CreateGuildAsync(name, region, iconb64, verificationLevel, defaultMessageNotifications, systemChannelFlags);
 	}
 
 	/// <summary>
 	/// Creates a guild from a template. This requires the bot to be in less than 10 guilds total.
 	/// </summary>
 	/// <param name="code">The template code.</param>
 	/// <param name="name">Name of the guild.</param>
 	/// <param name="icon">Stream containing the icon for the guild.</param>
 	/// <returns>The created guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<DiscordGuild> CreateGuildFromTemplateAsync(string code, string name, Optional<Stream> icon = default)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		return this.ApiClient.CreateGuildFromTemplateAsync(code, name, iconb64);
 	}
 
 	/// <summary>
 	/// Executes a raw request.
 	/// </summary>
 	/// <example>
 	/// <c>
 	/// var request = await Client.ExecuteRawRequestAsync(RestRequestMethod.GET, $"{Endpoints.CHANNELS}/243184972190742178964/{Endpoints.INVITES}");
 	/// List&lt;DiscordInvite&gt; invites = DiscordJson.ToDiscordObject&lt;List&lt;DiscordInvite&gt;&gt;(request.Response);
 	/// </c>
 	/// </example>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="routeParams">The route parameters.</param>
 	/// <param name="jsonBody">The json body.</param>
 	/// <param name="additionalHeaders">The additional headers.</param>
 	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the resource does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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>
 	/// <returns>A awaitable RestResponse</returns>
 	[Obsolete("This is no longer needed. Use DiscordClient.RestClient instead.", false)]
 	public async Task<RestResponse> ExecuteRawRequestAsync(RestRequestMethod method, string route, object routeParams, string jsonBody = null, Dictionary<string, string> additionalHeaders = null, double? ratelimitWaitOverride = null)
 	{
 		var bucket = this.ApiClient.Rest.GetBucket(method, route, routeParams, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Configuration);
 		var res = await this.ApiClient.DoRequestAsync(this, bucket, url, method, route, additionalHeaders, DiscordJson.SerializeObject(jsonBody), ratelimitWaitOverride);
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets a guild.
 	/// <para>Setting <paramref name="withCounts"/> to true will make a REST request.</para>
 	/// </summary>
 	/// <param name="id">The guild ID to search for.</param>
 	/// <param name="withCounts">Whether to include approximate presence and member counts in the returned guild.</param>
 	/// <returns>The requested Guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null)
 	{
 		if (this.GuildsInternal.TryGetValue(id, out var guild) && (!withCounts.HasValue || !withCounts.Value))
 			return guild;
 
 		guild = await this.ApiClient.GetGuildAsync(id, withCounts).ConfigureAwait(false);
 		var channels = await this.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
 		foreach (var channel in channels) guild.ChannelsInternal[channel.Id] = channel;
 
 		return guild;
 	}
 
 	/// <summary>
 	/// Gets a guild preview.
 	/// </summary>
 	/// <param name="id">The guild ID.</param>
 	/// <returns></returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
 		=> this.ApiClient.GetGuildPreviewAsync(id);
 
 	/// <summary>
 	/// Gets an invite.
 	/// </summary>
 	/// <param name="code">The invite code.</param>
 	/// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
 	/// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
 	/// <param name="scheduledEventId">The scheduled event id.</param>
 	/// <returns>The requested Invite.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the invite does not exists.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the invite 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 Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 		=> this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
 	/// <summary>
 	/// Gets a list of user connections.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<DiscordConnection>> GetConnectionsAsync()
 		=> this.ApiClient.GetUserConnectionsAsync();
 
 	/// <summary>
 	/// Gets a sticker.
 	/// </summary>
 	/// <returns>The requested sticker.</returns>
 	/// <param name="id">The id of the sticker.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the sticker does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the sticker 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<DiscordSticker> GetStickerAsync(ulong id)
 		=> this.ApiClient.GetStickerAsync(id);
 
 
 	/// <summary>
 	/// Gets all nitro sticker packs.
 	/// </summary>
 	/// <returns>List of sticker packs.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<DiscordStickerPack>> GetStickerPacksAsync()
 		=> this.ApiClient.GetStickerPacksAsync();
 
 
 	/// <summary>
 	/// Gets the In-App OAuth Url.
 	/// </summary>
 	/// <param name="scopes">Defaults to <see cref="DisCatSharp.Enums.OAuthScopes.BOT_DEFAULT"/>.</param>
 	/// <param name="redir">Redirect Uri.</param>
 	/// <param name="permissions">Defaults to <see cref="Permissions.None"/>.</param>
 	/// <returns>The OAuth Url</returns>
 	public Uri GetInAppOAuth(Permissions permissions = Permissions.None, OAuthScopes scopes = OAuthScopes.BOT_DEFAULT, string redir = null)
 	{
 		permissions &= PermissionMethods.FullPerms;
 		// hey look, it's not all annoying and blue :P
 		return new Uri(new QueryUriBuilder($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.OAUTH2}{Endpoints.AUTHORIZE}")
 			.AddParameter("client_id", this.CurrentApplication.Id.ToString(CultureInfo.InvariantCulture))
 			.AddParameter("scope", OAuth.ResolveScopes(scopes))
 			.AddParameter("permissions", ((long)permissions).ToString(CultureInfo.InvariantCulture))
 			.AddParameter("state", "")
 			.AddParameter("redirect_uri", redir ?? "")
 			.ToString());
 	}
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <returns>The requested webhook.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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<DiscordWebhook> GetWebhookAsync(ulong id)
 		=> this.ApiClient.GetWebhookAsync(id);
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <param name="token">The target webhook token.</param>
 	/// <returns>The requested webhook.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
 		=> this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
 	/// <summary>
 	/// Updates current user's activity and status.
 	/// </summary>
 	/// <param name="activity">Activity to set.</param>
 	/// <param name="userStatus">Status of the user.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 	/// <returns></returns>
 	public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 		=> this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
 	/// <summary>
 	/// Edits current user.
 	/// </summary>
 	/// <param name="username">New username.</param>
 	/// <param name="avatar">New avatar.</param>
 	/// <returns>The modified user.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user 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<DiscordUser> UpdateCurrentUserAsync(string username = null, Optional<Stream> avatar = default)
 	{
 		var av64 = ImageTool.Base64FromStream(avatar);
 
 		var usr = await this.ApiClient.ModifyCurrentUserAsync(username, av64).ConfigureAwait(false);
 
 		this.CurrentUser.Username = usr.Username;
 		this.CurrentUser.Discriminator = usr.Discriminator;
 		this.CurrentUser.AvatarHash = usr.AvatarHash;
 		return this.CurrentUser;
 	}
 
 	/// <summary>
 	/// Gets a guild template by the code.
 	/// </summary>
 	/// <param name="code">The code of the template.</param>
 	/// <returns>The guild template for the code.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<DiscordGuildTemplate> GetTemplateAsync(string code)
 		=> this.ApiClient.GetTemplateAsync(code);
 
 	/// <summary>
 	/// Gets all the global application commands for this application.
 	/// </summary>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	/// <returns>A list of global application commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(bool withLocalizations = false) =>
 		this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id, withLocalizations);
 
 	/// <summary>
 	/// Overwrites the existing global application commands. New commands are automatically created and missing commands are automatically deleted.
 	/// </summary>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of global commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 		this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, commands);
 
 	/// <summary>
 	/// Creates or overwrites a global application command.
 	/// </summary>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(DiscordApplicationCommand command) =>
 		this.ApiClient.CreateGlobalApplicationCommandAsync(this.CurrentApplication.Id, command);
 
 	/// <summary>
 	/// Gets a global application command by its id.
 	/// </summary>
 	/// <param name="commandId">The id of the command to get.</param>
 	/// <returns>The command with the id.</returns>
 	public Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong commandId) =>
 		this.ApiClient.GetGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 	/// <summary>
 	/// Edits a global application command.
 	/// </summary>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edited command.</returns>
 	public async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 		return await this.ApiClient.EditGlobalApplicationCommandAsync(applicationId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a global application command.
 	/// </summary>
 	/// <param name="commandId">The id of the command to delete.</param>
 	public Task DeleteGlobalApplicationCommandAsync(ulong commandId) =>
 		this.ApiClient.DeleteGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 	/// <summary>
 	/// Gets all the application commands for a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to get application commands for.</param>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	/// <returns>A list of application commands in the guild.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId, bool withLocalizations = false) =>
 		this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, withLocalizations);
 
 	/// <summary>
 	/// Overwrites the existing application commands in a guild. New commands are automatically created and missing commands are automatically deleted.
 	/// </summary>
 	/// <param name="guildId">The id of the guild.</param>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of guild commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordApplicationCommand> commands) =>
 		this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, commands);
 
 	/// <summary>
 	/// Creates or overwrites a guild application command.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to create the application command in.</param>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong guildId, DiscordApplicationCommand command) =>
 		this.ApiClient.CreateGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, command);
 
 	/// <summary>
 	/// Gets a application command in a guild by its id.
 	/// </summary>
 	/// <param name="guildId">The id of the guild the application command is in.</param>
 	/// <param name="commandId">The id of the command to get.</param>
 	/// <returns>The command with the id.</returns>
 	public Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 		 this.ApiClient.GetGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	/// <summary>
 	/// Edits a application command in a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild the application command is in.</param>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edited command.</returns>
 	public async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong guildId, ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 		return await this.ApiClient.EditGuildApplicationCommandAsync(applicationId, guildId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a application command in a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to delete the application command in.</param>
 	/// <param name="commandId">The id of the command.</param>
 	public Task DeleteGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 		this.ApiClient.DeleteGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	/// <summary>
 	/// Gets all command permissions for a guild.
 	/// </summary>
 	/// <param name="guildId">The target guild.</param>
 	public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong guildId) =>
 		this.ApiClient.GetGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId);
 
 	/// <summary>
 	/// Gets the permissions for a guild command.
 	/// </summary>
 	/// <param name="guildId">The target guild.</param>
 	/// <param name="commandId">The target command id.</param>
 	public Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong guildId, ulong commandId) =>
 		this.ApiClient.GetGuildApplicationCommandPermissionAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	#endregion
 
 	#region Internal Caching Methods
 	/// <summary>
 	/// Gets the internal cached threads.
 	/// </summary>
 	/// <param name="threadId">The target thread id.</param>
 	/// <returns>The requested thread.</returns>
 	internal DiscordThreadChannel InternalGetCachedThread(ulong threadId)
 	{
 		if (this.Guilds == null)
 			return null;
 
 		foreach (var guild in this.Guilds.Values)
 			if (guild.Threads.TryGetValue(threadId, out var foundThread))
 				return foundThread;
 
 		return null;
 	}
 
 
 	/// <summary>
 	/// Gets the internal cached scheduled event.
 	/// </summary>
 	/// <param name="scheduledEventId">The target scheduled event id.</param>
 	/// <returns>The requested scheduled event.</returns>
 	internal DiscordScheduledEvent InternalGetCachedScheduledEvent(ulong scheduledEventId)
 	{
 		if (this.Guilds == null)
 			return null;
 
 		foreach (var guild in this.Guilds.Values)
 			if (guild.ScheduledEvents.TryGetValue(scheduledEventId, out var foundScheduledEvent))
 				return foundScheduledEvent;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Gets the internal cached channel.
 	/// </summary>
 	/// <param name="channelId">The target channel id.</param>
 	/// <returns>The requested channel.</returns>
 	internal DiscordChannel InternalGetCachedChannel(ulong channelId)
 	{
 		if (this.Guilds == null)
 			return null;
 
 		foreach (var guild in this.Guilds.Values)
 			if (guild.Channels.TryGetValue(channelId, out var foundChannel))
 				return foundChannel;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Gets the internal cached guild.
 	/// </summary>
 	/// <param name="guildId">The target guild id.</param>
 	/// <returns>The requested guild.</returns>
 	internal DiscordGuild InternalGetCachedGuild(ulong? guildId)
 	{
 		if (this.GuildsInternal != null && guildId.HasValue)
 		{
 			if (this.GuildsInternal.TryGetValue(guildId.Value, out var guild))
 				return guild;
 		}
 
 		return null;
 	}
 
 	/// <summary>
 	/// Updates a message.
 	/// </summary>
 	/// <param name="message">The message to update.</param>
 	/// <param name="author">The author to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <param name="member">The member to update.</param>
 	private void UpdateMessage(DiscordMessage message, TransportUser author, DiscordGuild guild, TransportMember member)
 	{
 		if (author != null)
 		{
 			var usr = new DiscordUser(author) { Discord = this };
 
 			if (member != null)
 				member.User = author;
 
 			message.Author = this.UpdateUser(usr, guild?.Id, guild, member);
 		}
 
 		var channel = this.InternalGetCachedChannel(message.ChannelId);
 
 		if (channel != null) return;
 
 		channel = !message.GuildId.HasValue
 			? new DiscordDmChannel
 			{
 				Id = message.ChannelId,
 				Discord = this,
 				Type = ChannelType.Private
 			}
 			: new DiscordChannel
 			{
 				Id = message.ChannelId,
 				Discord = this
 			};
 
 		message.Channel = channel;
 	}
 
 	/// <summary>
 	/// Updates a scheduled event.
 	/// </summary>
 	/// <param name="scheduledEvent">The scheduled event to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <returns>The updated scheduled event.</returns>
 	private DiscordScheduledEvent UpdateScheduledEvent(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		if (scheduledEvent != null)
 		{
 			_ = guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (id, old) =>
 			{
 				old.Discord = this;
 				old.Description = scheduledEvent.Description;
 				old.ChannelId = scheduledEvent.ChannelId;
 				old.EntityId = scheduledEvent.EntityId;
 				old.EntityType = scheduledEvent.EntityType;
 				old.EntityMetadata = scheduledEvent.EntityMetadata;
 				old.PrivacyLevel = scheduledEvent.PrivacyLevel;
 				old.Name = scheduledEvent.Name;
 				old.Status = scheduledEvent.Status;
 				old.UserCount = scheduledEvent.UserCount;
 				old.ScheduledStartTimeRaw = scheduledEvent.ScheduledStartTimeRaw;
 				old.ScheduledEndTimeRaw = scheduledEvent.ScheduledEndTimeRaw;
 				return old;
 			});
 		}
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Updates a user.
 	/// </summary>
 	/// <param name="usr">The user to update.</param>
 	/// <param name="guildId">The guild id to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <param name="mbr">The member to update.</param>
 	/// <returns>The updated user.</returns>
 	private DiscordUser UpdateUser(DiscordUser usr, ulong? guildId, DiscordGuild guild, TransportMember mbr)
 	{
 		if (mbr != null)
 		{
 			if (mbr.User != null)
 			{
 				usr = new DiscordUser(mbr.User) { Discord = this };
 
 				_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					old.BannerHash = usr.BannerHash;
 					old.BannerColorInternal = usr.BannerColorInternal;
 					old.AvatarDecorationHash = usr.AvatarDecorationHash;
 					old.ThemeColorsInternal = usr.ThemeColorsInternal;
 					old.Pronouns = usr.Pronouns;
 					return old;
 				});
 
 				usr = new DiscordMember(mbr) { Discord = this, GuildId = guildId.Value };
 			}
 
 			var intents = this.Configuration.Intents;
 
 			DiscordMember member = default;
 
 			if (!intents.HasAllPrivilegedIntents() || guild.IsLarge) // we have the necessary privileged intents, no need to worry about caching here unless guild is large.
 			{
 				if (guild?.MembersInternal.TryGetValue(usr.Id, out member) == false)
 				{
 					if (intents.HasIntent(DiscordIntents.GuildMembers) || this.Configuration.AlwaysCacheMembers) // member can be updated by events, so cache it
 					{
 						guild.MembersInternal.TryAdd(usr.Id, (DiscordMember)usr);
 					}
 				}
 				else if (intents.HasIntent(DiscordIntents.GuildPresences) || this.Configuration.AlwaysCacheMembers) // we can attempt to update it if it's already in cache.
 				{
 					if (!intents.HasIntent(DiscordIntents.GuildMembers)) // no need to update if we already have the member events
 					{
 						_ = guild.MembersInternal.TryUpdate(usr.Id, (DiscordMember)usr, member);
 					}
 				}
 			}
 		}
 		else if (usr.Username != null) // check if not a skeleton user
 		{
 			_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				old.BannerHash = usr.BannerHash;
 				old.BannerColorInternal = usr.BannerColorInternal;
 				old.AvatarDecorationHash = usr.AvatarDecorationHash;
 				old.ThemeColorsInternal = usr.ThemeColorsInternal;
 				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 		}
 
 		return usr;
 	}
 
 	/// <summary>
 	/// Updates the cached scheduled events in a guild.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawEvents">The raw events.</param>
 	private void UpdateCachedScheduledEvent(DiscordGuild guild, JArray rawEvents)
 	{
 		if (this._disposed)
 			return;
 
 		if (rawEvents != null)
 		{
 			guild.ScheduledEventsInternal.Clear();
 
 			foreach (var xj in rawEvents)
 			{
 				var xtm = xj.ToDiscordObject<DiscordScheduledEvent>();
 
 				xtm.Discord = this;
 
 				guild.ScheduledEventsInternal[xtm.Id] = xtm;
 			}
 		}
 	}
 
 	/// <summary>
 	/// Updates the cached guild.
 	/// </summary>
 	/// <param name="newGuild">The new guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	private void UpdateCachedGuild(DiscordGuild newGuild, JArray rawMembers)
 	{
 		if (this._disposed)
 			return;
 
 		if (!this.GuildsInternal.ContainsKey(newGuild.Id))
 			this.GuildsInternal[newGuild.Id] = newGuild;
 
 		var guild = this.GuildsInternal[newGuild.Id];
 
 		if (newGuild.ChannelsInternal != null && !newGuild.ChannelsInternal.IsEmpty)
 		{
 			foreach (var channel in newGuild.ChannelsInternal.Values)
 			{
 				if (guild.ChannelsInternal.TryGetValue(channel.Id, out _)) continue;
 
 				channel.Initialize(this);
 
 				guild.ChannelsInternal[channel.Id] = channel;
 			}
 		}
 
 		if (newGuild.ThreadsInternal != null && !newGuild.ThreadsInternal.IsEmpty)
 		{
 			foreach (var thread in newGuild.ThreadsInternal.Values)
 			{
 				if (guild.ThreadsInternal.TryGetValue(thread.Id, out _)) continue;
 
 				guild.ThreadsInternal[thread.Id] = thread;
 			}
 		}
 
 		if (newGuild.ScheduledEventsInternal != null && !newGuild.ScheduledEventsInternal.IsEmpty)
 		{
 			foreach (var @event in newGuild.ScheduledEventsInternal.Values)
 			{
 				if (guild.ScheduledEventsInternal.TryGetValue(@event.Id, out _)) continue;
 
 				guild.ScheduledEventsInternal[@event.Id] = @event;
 			}
 		}
 
 		foreach (var newEmoji in newGuild.EmojisInternal.Values)
 			_ = guild.EmojisInternal.GetOrAdd(newEmoji.Id, _ => newEmoji);
 
 		foreach (var newSticker in newGuild.StickersInternal.Values)
 			_ = guild.StickersInternal.GetOrAdd(newSticker.Id, _ => newSticker);
 
 		foreach (var newStageInstance in newGuild.StageInstancesInternal.Values)
 			_ = guild.StageInstancesInternal.GetOrAdd(newStageInstance.Id, _ => newStageInstance);
 
 		if (rawMembers != null)
 		{
 			guild.MembersInternal.Clear();
 
 			foreach (var xj in rawMembers)
 			{
 				var xtm = xj.ToDiscordObject<TransportMember>();
 
 				var xu = new DiscordUser(xtm.User) { Discord = this };
 				_ = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 				{
 					old.Username = xu.Username;
 					old.Discriminator = xu.Discriminator;
 					old.AvatarHash = xu.AvatarHash;
 					old.PremiumType = xu.PremiumType;
 					return old;
 				});
 
 				guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 			}
 		}
 
 		foreach (var role in newGuild.RolesInternal.Values)
 		{
 			if (guild.RolesInternal.TryGetValue(role.Id, out _)) continue;
 
 			role.GuildId = guild.Id;
 			guild.RolesInternal[role.Id] = role;
 		}
 
 		guild.Name = newGuild.Name;
 		guild.AfkChannelId = newGuild.AfkChannelId;
 		guild.AfkTimeout = newGuild.AfkTimeout;
 		guild.DefaultMessageNotifications = newGuild.DefaultMessageNotifications;
 		guild.RawFeatures = newGuild.RawFeatures;
 		guild.IconHash = newGuild.IconHash;
 		guild.MfaLevel = newGuild.MfaLevel;
 		guild.OwnerId = newGuild.OwnerId;
 		guild.VoiceRegionId = newGuild.VoiceRegionId;
 		guild.SplashHash = newGuild.SplashHash;
 		guild.VerificationLevel = newGuild.VerificationLevel;
 		guild.WidgetEnabled = newGuild.WidgetEnabled;
 		guild.WidgetChannelId = newGuild.WidgetChannelId;
 		guild.ExplicitContentFilter = newGuild.ExplicitContentFilter;
 		guild.PremiumTier = newGuild.PremiumTier;
 		guild.PremiumSubscriptionCount = newGuild.PremiumSubscriptionCount;
 		guild.PremiumProgressBarEnabled = newGuild.PremiumProgressBarEnabled;
 		guild.BannerHash = newGuild.BannerHash;
 		guild.Description = newGuild.Description;
 		guild.VanityUrlCode = newGuild.VanityUrlCode;
 		guild.SystemChannelId = newGuild.SystemChannelId;
 		guild.SystemChannelFlags = newGuild.SystemChannelFlags;
 		guild.DiscoverySplashHash = newGuild.DiscoverySplashHash;
 		guild.MaxMembers = newGuild.MaxMembers;
 		guild.MaxPresences = newGuild.MaxPresences;
 		guild.ApproximateMemberCount = newGuild.ApproximateMemberCount;
 		guild.ApproximatePresenceCount = newGuild.ApproximatePresenceCount;
 		guild.MaxVideoChannelUsers = newGuild.MaxVideoChannelUsers;
 		guild.PreferredLocale = newGuild.PreferredLocale;
 		guild.RulesChannelId = newGuild.RulesChannelId;
 		guild.PublicUpdatesChannelId = newGuild.PublicUpdatesChannelId;
 		guild.ApplicationId = newGuild.ApplicationId;
 
 		// fields not sent for update:
 		// - guild.Channels
 		// - voice states
 		// - guild.JoinedAt = new_guild.JoinedAt;
 		// - guild.Large = new_guild.Large;
 		// - guild.MemberCount = Math.Max(new_guild.MemberCount, guild._members.Count);
 		// - guild.Unavailable = new_guild.Unavailable;
 	}
 
 	/// <summary>
 	/// Populates the message reactions and cache.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The author.</param>
 	/// <param name="member">The member.</param>
 	private void PopulateMessageReactionsAndCache(DiscordMessage message, TransportUser author, TransportMember member)
 	{
 		var guild = message.Channel?.Guild ?? this.InternalGetCachedGuild(message.GuildId);
 
 		this.UpdateMessage(message, author, guild, member);
 
 		message.ReactionsInternal ??= new List<DiscordReaction>();
 		foreach (var xr in message.ReactionsInternal)
 			xr.Emoji.Discord = this;
 
 		if (this.Configuration.MessageCacheSize > 0 && message.Channel != null)
 			this.MessageCache?.Add(message);
 	}
 
 
 	#endregion
 
 	#region Disposal
 
 	~DiscordClient()
 	{
 		this.Dispose();
 	}
 
 	/// <summary>
 	/// Whether the client is disposed.
 	/// </summary>
 
 	private bool _disposed;
 
 	/// <summary>
 	/// Disposes the client.
 	/// </summary>
 	public override void Dispose()
 	{
 		if (this._disposed)
 			return;
 
 		this._disposed = true;
 		GC.SuppressFinalize(this);
 
 		this.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 		this.ApiClient.Rest.Dispose();
 		this.CurrentUser = null;
 
 		var extensions = this._extensions; // prevent _extensions being modified during dispose
 		this._extensions = null;
 		foreach (var extension in extensions)
 			if (extension is IDisposable disposable)
 				disposable.Dispose();
 
 		try
 		{
 			this._cancelTokenSource?.Cancel();
 			this._cancelTokenSource?.Dispose();
 		}
 		catch { }
 
 		this.GuildsInternal = null;
 		this._heartbeatTask = null;
 	}
 
 	#endregion
 }
diff --git a/DisCatSharp/Clients/DiscordShardedClient.cs b/DisCatSharp/Clients/DiscordShardedClient.cs
index c45a22082..5fd5084e7 100644
--- a/DisCatSharp/Clients/DiscordShardedClient.cs
+++ b/DisCatSharp/Clients/DiscordShardedClient.cs
@@ -1,781 +1,781 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A Discord client that shards automatically.
 /// </summary>
 public sealed partial class DiscordShardedClient
 {
 	#region Public Properties
 
 	/// <summary>
 	/// Gets the logger for this client.
 	/// </summary>
 	public ILogger<BaseDiscordClient> Logger { get; }
 
 	/// <summary>
 	/// Gets all client shards.
 	/// </summary>
 	public IReadOnlyDictionary<int, DiscordClient> ShardClients { get; }
 
 	/// <summary>
 	/// Gets the gateway info for the client's session.
 	/// </summary>
 	public GatewayInfo GatewayInfo { get; private set; }
 
 	/// <summary>
 	/// Gets the current user.
 	/// </summary>
 	public DiscordUser CurrentUser { get; private set; }
 
 	/// <summary>
 	/// Gets the current application.
 	/// </summary>
 	public DiscordApplication CurrentApplication { get; private set; }
 
 	[Obsolete("Use GetLibraryDevelopmentTeamAsync")]
 	public DisCatSharpTeam LibraryDeveloperTeam
 		=> this.GetLibraryDevelopmentTeamAsync().Result;
 
 	/// <summary>
 	/// Gets the list of available voice regions. Note that this property will not contain VIP voice regions.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordVoiceRegion> VoiceRegions
 		=> this._voiceRegionsLazy?.Value;
 
 	#endregion
 
 	#region Private Properties/Fields
 
 	/// <summary>
 	/// Gets the configuration.
 	/// </summary>
 	private readonly DiscordConfiguration _configuration;
 
 	/// <summary>
 	/// Gets the list of available voice regions. This property is meant as a way to modify <see cref="VoiceRegions"/>.
 	/// </summary>
 	private ConcurrentDictionary<string, DiscordVoiceRegion> _internalVoiceRegions;
 
 	/// <summary>
 	/// Gets a list of shards.
 	/// </summary>
 	private readonly ConcurrentDictionary<int, DiscordClient> _shards = new();
 
 	/// <summary>
 	/// Gets a lazy list of voice regions.
 	/// </summary>
 	private Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> _voiceRegionsLazy;
 
 	/// <summary>
 	/// Whether the shard client is started.
 	/// </summary>
 	private bool _isStarted;
 
 	/// <summary>
 	/// Whether manual sharding is enabled.
 	/// </summary>
 	private readonly bool _manuallySharding;
 
 	#endregion
 
 	#region Constructor
 
 	/// <summary>
 	/// Initializes a new auto-sharding Discord client.
 	/// </summary>
 	/// <param name="config">The configuration to use.</param>
 	public DiscordShardedClient(DiscordConfiguration config)
 	{
 		this.InternalSetup();
 
 		if (config.ShardCount > 1)
 			this._manuallySharding = true;
 
 		this._configuration = config;
 		this.ShardClients = new ReadOnlyConcurrentDictionary<int, DiscordClient>(this._shards);
 
 		if (this._configuration.LoggerFactory == null)
 		{
 			this._configuration.LoggerFactory = new DefaultLoggerFactory();
 			this._configuration.LoggerFactory.AddProvider(new DefaultLoggerProvider(this._configuration.MinimumLogLevel, this._configuration.LogTimestampFormat));
 		}
 		this.Logger = this._configuration.LoggerFactory.CreateLogger<BaseDiscordClient>();
 	}
 
 	#endregion
 
 	#region Public Methods
 
 	/// <summary>
 	/// Initializes and connects all shards.
 	/// </summary>
-	/// <exception cref="System.AggregateException"></exception>
-	/// <exception cref="System.InvalidOperationException"></exception>
+	/// <exception cref="AggregateException"></exception>
+	/// <exception cref="InvalidOperationException"></exception>
 	public async Task StartAsync()
 	{
 		if (this._isStarted)
 			throw new InvalidOperationException("This client has already been started.");
 
 		this._isStarted = true;
 
 		try
 		{
 			if (this._configuration.TokenType != TokenType.Bot)
 				this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 			this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this._botLibrary, this._versionString.Value);
 
 			var shardc = await this.InitializeShardsAsync().ConfigureAwait(false);
 			var connectTasks = new List<Task>();
 			this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booting {0} shards.", shardc);
 
 			for (var i = 0; i < shardc; i++)
 			{
 				//This should never happen, but in case it does...
 				if (this.GatewayInfo.SessionBucket.MaxConcurrency < 1)
 					this.GatewayInfo.SessionBucket.MaxConcurrency = 1;
 
 				if (this.GatewayInfo.SessionBucket.MaxConcurrency == 1)
 					await this.ConnectShardAsync(i).ConfigureAwait(false);
 				else
 				{
 					//Concurrent login.
 					connectTasks.Add(this.ConnectShardAsync(i));
 
 					if (connectTasks.Count == this.GatewayInfo.SessionBucket.MaxConcurrency)
 					{
 						await Task.WhenAll(connectTasks).ConfigureAwait(false);
 						connectTasks.Clear();
 					}
 				}
 			}
 		}
 		catch (Exception ex)
 		{
 			await this.InternalStopAsync(false).ConfigureAwait(false);
 
 			var message = $"Shard initialization failed, check inner exceptions for details: ";
 
 			this.Logger.LogCritical(LoggerEvents.ShardClientError, $"{message}\n{ex}");
 			throw new AggregateException(message, ex);
 		}
 	}
 
 	/// <summary>
 	/// Disconnects and disposes all shards.
 	/// </summary>
-	/// <exception cref="System.InvalidOperationException"></exception>
+	/// <exception cref="InvalidOperationException"></exception>
 	public Task StopAsync()
 		=> this.InternalStopAsync();
 
 	/// <summary>
 	/// Gets a shard from a guild id.
 	/// <para>
 	///     If automatically sharding, this will use the <see cref="Utilities.GetShardId(ulong, int)"/> method.
 	///     Otherwise if manually sharding, it will instead iterate through each shard's guild caches.
 	/// </para>
 	/// </summary>
 	/// <param name="guildId">The guild ID for the shard.</param>
 	/// <returns>The found <see cref="DiscordClient"/> shard. Otherwise null if the shard was not found for the guild id.</returns>
 	public DiscordClient GetShard(ulong guildId)
 	{
 		var index = this._manuallySharding ? this.GetShardIdFromGuilds(guildId) : Utilities.GetShardId(guildId, this.ShardClients.Count);
 
 		return index != -1 ? this._shards[index] : null;
 	}
 
 	/// <summary>
 	/// Gets a shard from a guild.
 	/// <para>
 	///     If automatically sharding, this will use the <see cref="Utilities.GetShardId(ulong, int)"/> method.
 	///     Otherwise if manually sharding, it will instead iterate through each shard's guild caches.
 	/// </para>
 	/// </summary>
 	/// <param name="guild">The guild for the shard.</param>
 	/// <returns>The found <see cref="DiscordClient"/> shard. Otherwise null if the shard was not found for the guild.</returns>
 	public DiscordClient GetShard(DiscordGuild guild)
 		=> this.GetShard(guild.Id);
 
 	/// <summary>
 	/// Updates the status on all shards.
 	/// </summary>
 	/// <param name="activity">The activity to set. Defaults to null.</param>
 	/// <param name="userStatus">The optional status to set. Defaults to null.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity. Defaults to null.</param>
 	/// <returns>Asynchronous operation.</returns>
 	public async Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 	{
 		var tasks = new List<Task>();
 		foreach (var client in this._shards.Values)
 			tasks.Add(client.UpdateStatusAsync(activity, userStatus, idleSince));
 
 		await Task.WhenAll(tasks).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// <see cref="BaseDiscordClient.GetLibraryDevelopmentTeamAsync"/>
 	/// </summary>
 	public async Task<DisCatSharpTeam> GetLibraryDevelopmentTeamAsync()
 		=> await this.GetShard(0).GetLibraryDevelopmentTeamAsync().ConfigureAwait(false);
 
 	#endregion
 
 	#region Internal Methods
 
 	/// <summary>
 	/// Initializes the shards.
 	/// </summary>
 	/// <returns>The count of initialized shards.</returns>
 	internal async Task<int> InitializeShardsAsync()
 	{
 		if (!this._shards.IsEmpty)
 			return this._shards.Count;
 
 		this.GatewayInfo = await this.GetGatewayInfoAsync().ConfigureAwait(false);
 		var shardCount = this._configuration.ShardCount == 1 ? this.GatewayInfo.ShardCount : this._configuration.ShardCount;
 		var lf = new ShardedLoggerFactory(this.Logger);
 		for (var i = 0; i < shardCount; i++)
 		{
 			var cfg = new DiscordConfiguration(this._configuration)
 			{
 				ShardId = i,
 				ShardCount = shardCount,
 				LoggerFactory = lf
 			};
 
 			var client = new DiscordClient(cfg);
 			if (!this._shards.TryAdd(i, client))
 				throw new InvalidOperationException("Could not initialize shards.");
 		}
 
 		return shardCount;
 	}
 
 	#endregion
 
 	#region Private Methods & Version Property
 
 	/// <summary>
 	/// Gets the gateway info.
 	/// </summary>
 	private async Task<GatewayInfo> GetGatewayInfoAsync()
 	{
 		var url = $"{Utilities.GetApiBaseUri(this._configuration)}{Endpoints.GATEWAY}{Endpoints.BOT}";
 		var http = new HttpClient();
 
 		http.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 		http.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", Utilities.GetFormattedToken(this._configuration));
 		http.DefaultRequestHeaders.TryAddWithoutValidation("X-Discord-Locale", this._configuration.Locale);
 		if (this._configuration != null && this._configuration.Override != null)
 		{
 			http.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this._configuration.Override);
 		}
 
 		this.Logger.LogDebug(LoggerEvents.ShardRest, $"Obtaining gateway information from GET {Endpoints.GATEWAY}{Endpoints.BOT}...");
 		var resp = await http.GetAsync(url).ConfigureAwait(false);
 
 		http.Dispose();
 
 		if (!resp.IsSuccessStatusCode)
 		{
 			var ratelimited = await HandleHttpError(url, resp).ConfigureAwait(false);
 
 			if (ratelimited)
 				return await this.GetGatewayInfoAsync().ConfigureAwait(false);
 		}
 
 		var timer = new Stopwatch();
 		timer.Start();
 
 		var jo = JObject.Parse(await resp.Content.ReadAsStringAsync().ConfigureAwait(false));
 		var info = jo.ToObject<GatewayInfo>();
 
 		//There is a delay from parsing here.
 		timer.Stop();
 
 		info.SessionBucket.ResetAfterInternal -= (int)timer.ElapsedMilliseconds;
 		info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.ResetAfterInternal);
 
 		return info;
 
 		async Task<bool> HandleHttpError(string reqUrl, HttpResponseMessage msg)
 		{
 			var code = (int)msg.StatusCode;
 
 			if (code == 401 || code == 403)
 			{
 				throw new Exception($"Authentication failed, check your token and try again: {code} {msg.ReasonPhrase}");
 			}
 			else if (code == 429)
 			{
 				this.Logger.LogError(LoggerEvents.ShardClientError, $"Ratelimit hit, requeuing request to {reqUrl}");
 
 				var hs = msg.Headers.ToDictionary(xh => xh.Key, xh => string.Join("\n", xh.Value), StringComparer.OrdinalIgnoreCase);
 				var waitInterval = 0;
 
 				if (hs.TryGetValue("Retry-After", out var retryAfterRaw))
 					waitInterval = int.Parse(retryAfterRaw, CultureInfo.InvariantCulture);
 
 				await Task.Delay(waitInterval).ConfigureAwait(false);
 				return true;
 			}
 			else if (code >= 500)
 			{
 				throw new Exception($"Internal Server Error: {code} {msg.ReasonPhrase}");
 			}
 			else
 			{
 				throw new Exception($"An unsuccessful HTTP status code was encountered: {code} {msg.ReasonPhrase}");
 			}
 		}
 	}
 
 	/// <summary>
 	/// Gets the version string.
 	/// </summary>
 	private readonly Lazy<string> _versionString = new(() =>
 	{
 		var a = typeof(DiscordShardedClient).GetTypeInfo().Assembly;
 
 		var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (iv != null)
 			return iv.InformationalVersion;
 
 		var v = a.GetName().Version;
 		var vs = v.ToString(3);
 
 		if (v.Revision > 0)
 			vs = $"{vs}, CI build {v.Revision}";
 
 		return vs;
 	});
 
 	/// <summary>
 	/// Gets the name of the used bot library.
 	/// </summary>
 	private readonly string _botLibrary = "DisCatSharp";
 
 	#endregion
 
 	#region Private Connection Methods
 
 	/// <summary>
 	/// Connects a shard.
 	/// </summary>
 	/// <param name="i">The shard id.</param>
 	private async Task ConnectShardAsync(int i)
 	{
 		if (!this._shards.TryGetValue(i, out var client))
 			throw new Exception($"Could not initialize shard {i}.");
 
 		client.IsShard = true;
 		if (this.GatewayInfo != null)
 		{
 			client.GatewayInfo = this.GatewayInfo;
 			client.GatewayUri = new Uri(client.GatewayInfo.Url);
 		}
 
 		if (this.CurrentUser != null)
 			client.CurrentUser = this.CurrentUser;
 
 		if (this.CurrentApplication != null)
 			client.CurrentApplication = this.CurrentApplication;
 
 		if (this._internalVoiceRegions != null)
 		{
 			client.InternalVoiceRegions = this._internalVoiceRegions;
 			client.VoiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(client.InternalVoiceRegions));
 		}
 
 		this.HookEventHandlers(client);
 
 		await client.ConnectAsync();
 		this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booted shard {0}.", i);
 
 		this.GatewayInfo ??= client.GatewayInfo;
 
 		if (this.CurrentUser == null)
 			this.CurrentUser = client.CurrentUser;
 
 		if (this.CurrentApplication == null)
 			this.CurrentApplication = client.CurrentApplication;
 
 		if (this._internalVoiceRegions == null)
 		{
 			this._internalVoiceRegions = client.InternalVoiceRegions;
 			this._voiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(this._internalVoiceRegions));
 		}
 	}
 
 	/// <summary>
 	/// Stops all shards.
 	/// </summary>
 	/// <param name="enableLogger">Whether to enable the logger.</param>
 	private Task InternalStopAsync(bool enableLogger = true)
 	{
 		if (!this._isStarted)
 			throw new InvalidOperationException("This client has not been started.");
 
 		if (enableLogger)
 			this.Logger.LogInformation(LoggerEvents.ShardShutdown, "Disposing {0} shards.", this._shards.Count);
 
 		this._isStarted = false;
 		this._voiceRegionsLazy = null;
 
 		this.GatewayInfo = null;
 		this.CurrentUser = null;
 		this.CurrentApplication = null;
 
 		for (var i = 0; i < this._shards.Count; i++)
 		{
 			if (this._shards.TryGetValue(i, out var client))
 			{
 				this.UnhookEventHandlers(client);
 
 				client.Dispose();
 
 				if (enableLogger)
 					this.Logger.LogInformation(LoggerEvents.ShardShutdown, "Disconnected shard {0}.", i);
 			}
 		}
 
 		this._shards.Clear();
 
 		return Task.CompletedTask;
 	}
 
 	#endregion
 
 	#region Event Handler Initialization/Registering
 
 	/// <summary>
 	/// Sets the shard client up internally..
 	/// </summary>
 	private void InternalSetup()
 	{
 		this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", DiscordClient.EventExecutionLimit, this.Goof);
 		this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", DiscordClient.EventExecutionLimit, this.Goof);
 		this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildDownloadCompleted = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMembersChunk = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutAdded = new AsyncEvent<DiscordClient, GuildMemberTimeoutAddEventArgs>("GUILD_MEMBER_TIMEOUT_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutChanged = new AsyncEvent<DiscordClient, GuildMemberTimeoutUpdateEventArgs>("GUILD_MEMBER_TIMEOUT_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutRemoved = new AsyncEvent<DiscordClient, GuildMemberTimeoutRemoveEventArgs>("GUILD_MEMBER_TIMEOUT_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 	}
 
 	/// <summary>
 	/// Hooks the event handlers.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	private void HookEventHandlers(DiscordClient client)
 	{
 		client.ClientErrored += this.Client_ClientError;
 		client.SocketErrored += this.Client_SocketError;
 		client.SocketOpened += this.Client_SocketOpened;
 		client.SocketClosed += this.Client_SocketClosed;
 		client.Ready += this.Client_Ready;
 		client.Resumed += this.Client_Resumed;
 		client.ChannelCreated += this.Client_ChannelCreated;
 		client.ChannelUpdated += this.Client_ChannelUpdated;
 		client.ChannelDeleted += this.Client_ChannelDeleted;
 		client.DmChannelDeleted += this.Client_DMChannelDeleted;
 		client.ChannelPinsUpdated += this.Client_ChannelPinsUpdated;
 		client.GuildCreated += this.Client_GuildCreated;
 		client.GuildAvailable += this.Client_GuildAvailable;
 		client.GuildUpdated += this.Client_GuildUpdated;
 		client.GuildDeleted += this.Client_GuildDeleted;
 		client.GuildUnavailable += this.Client_GuildUnavailable;
 		client.GuildDownloadCompleted += this.Client_GuildDownloadCompleted;
 		client.InviteCreated += this.Client_InviteCreated;
 		client.InviteDeleted += this.Client_InviteDeleted;
 		client.MessageCreated += this.Client_MessageCreated;
 		client.PresenceUpdated += this.Client_PresenceUpdate;
 		client.GuildBanAdded += this.Client_GuildBanAdd;
 		client.GuildBanRemoved += this.Client_GuildBanRemove;
 		client.GuildEmojisUpdated += this.Client_GuildEmojisUpdate;
 		client.GuildStickersUpdated += this.Client_GuildStickersUpdate;
 		client.GuildIntegrationsUpdated += this.Client_GuildIntegrationsUpdate;
 		client.GuildMemberAdded += this.Client_GuildMemberAdd;
 		client.GuildMemberRemoved += this.Client_GuildMemberRemove;
 		client.GuildMemberUpdated += this.Client_GuildMemberUpdate;
 		client.GuildRoleCreated += this.Client_GuildRoleCreate;
 		client.GuildRoleUpdated += this.Client_GuildRoleUpdate;
 		client.GuildRoleDeleted += this.Client_GuildRoleDelete;
 		client.MessageUpdated += this.Client_MessageUpdate;
 		client.MessageDeleted += this.Client_MessageDelete;
 		client.MessagesBulkDeleted += this.Client_MessageBulkDelete;
 		client.InteractionCreated += this.Client_InteractionCreate;
 		client.ComponentInteractionCreated += this.Client_ComponentInteractionCreate;
 		client.ContextMenuInteractionCreated += this.Client_ContextMenuInteractionCreate;
 		client.TypingStarted += this.Client_TypingStart;
 		client.UserSettingsUpdated += this.Client_UserSettingsUpdate;
 		client.UserUpdated += this.Client_UserUpdate;
 		client.VoiceStateUpdated += this.Client_VoiceStateUpdate;
 		client.VoiceServerUpdated += this.Client_VoiceServerUpdate;
 		client.GuildMembersChunked += this.Client_GuildMembersChunk;
 		client.UnknownEvent += this.Client_UnknownEvent;
 		client.MessageReactionAdded += this.Client_MessageReactionAdd;
 		client.MessageReactionRemoved += this.Client_MessageReactionRemove;
 		client.MessageReactionsCleared += this.Client_MessageReactionRemoveAll;
 		client.MessageReactionRemovedEmoji += this.Client_MessageReactionRemovedEmoji;
 		client.WebhooksUpdated += this.Client_WebhooksUpdate;
 		client.Heartbeated += this.Client_HeartBeated;
 		client.ApplicationCommandCreated += this.Client_ApplicationCommandCreated;
 		client.ApplicationCommandUpdated += this.Client_ApplicationCommandUpdated;
 		client.ApplicationCommandDeleted += this.Client_ApplicationCommandDeleted;
 		client.GuildApplicationCommandCountUpdated += this.Client_GuildApplicationCommandCountUpdated;
 		client.ApplicationCommandPermissionsUpdated += this.Client_ApplicationCommandPermissionsUpdated;
 		client.GuildIntegrationCreated += this.Client_GuildIntegrationCreated;
 		client.GuildIntegrationUpdated += this.Client_GuildIntegrationUpdated;
 		client.GuildIntegrationDeleted += this.Client_GuildIntegrationDeleted;
 		client.StageInstanceCreated += this.Client_StageInstanceCreated;
 		client.StageInstanceUpdated += this.Client_StageInstanceUpdated;
 		client.StageInstanceDeleted += this.Client_StageInstanceDeleted;
 		client.ThreadCreated += this.Client_ThreadCreated;
 		client.ThreadUpdated += this.Client_ThreadUpdated;
 		client.ThreadDeleted += this.Client_ThreadDeleted;
 		client.ThreadListSynced += this.Client_ThreadListSynced;
 		client.ThreadMemberUpdated += this.Client_ThreadMemberUpdated;
 		client.ThreadMembersUpdated += this.Client_ThreadMembersUpdated;
 		client.Zombied += this.Client_Zombied;
 		client.PayloadReceived += this.Client_PayloadReceived;
 		client.GuildScheduledEventCreated += this.Client_GuildScheduledEventCreated;
 		client.GuildScheduledEventUpdated += this.Client_GuildScheduledEventUpdated;
 		client.GuildScheduledEventDeleted += this.Client_GuildScheduledEventDeleted;
 		client.GuildScheduledEventUserAdded += this.Client_GuildScheduledEventUserAdded; ;
 		client.GuildScheduledEventUserRemoved += this.Client_GuildScheduledEventUserRemoved;
 		client.EmbeddedActivityUpdated += this.Client_EmbeddedActivityUpdated;
 		client.GuildMemberTimeoutAdded += this.Client_GuildMemberTimeoutAdded;
 		client.GuildMemberTimeoutChanged += this.Client_GuildMemberTimeoutChanged;
 		client.GuildMemberTimeoutRemoved += this.Client_GuildMemberTimeoutRemoved;
 	}
 
 	/// <summary>
 	/// Unhooks the event handlers.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	private void UnhookEventHandlers(DiscordClient client)
 	{
 		client.ClientErrored -= this.Client_ClientError;
 		client.SocketErrored -= this.Client_SocketError;
 		client.SocketOpened -= this.Client_SocketOpened;
 		client.SocketClosed -= this.Client_SocketClosed;
 		client.Ready -= this.Client_Ready;
 		client.Resumed -= this.Client_Resumed;
 		client.ChannelCreated -= this.Client_ChannelCreated;
 		client.ChannelUpdated -= this.Client_ChannelUpdated;
 		client.ChannelDeleted -= this.Client_ChannelDeleted;
 		client.DmChannelDeleted -= this.Client_DMChannelDeleted;
 		client.ChannelPinsUpdated -= this.Client_ChannelPinsUpdated;
 		client.GuildCreated -= this.Client_GuildCreated;
 		client.GuildAvailable -= this.Client_GuildAvailable;
 		client.GuildUpdated -= this.Client_GuildUpdated;
 		client.GuildDeleted -= this.Client_GuildDeleted;
 		client.GuildUnavailable -= this.Client_GuildUnavailable;
 		client.GuildDownloadCompleted -= this.Client_GuildDownloadCompleted;
 		client.InviteCreated -= this.Client_InviteCreated;
 		client.InviteDeleted -= this.Client_InviteDeleted;
 		client.MessageCreated -= this.Client_MessageCreated;
 		client.PresenceUpdated -= this.Client_PresenceUpdate;
 		client.GuildBanAdded -= this.Client_GuildBanAdd;
 		client.GuildBanRemoved -= this.Client_GuildBanRemove;
 		client.GuildEmojisUpdated -= this.Client_GuildEmojisUpdate;
 		client.GuildStickersUpdated -= this.Client_GuildStickersUpdate;
 		client.GuildIntegrationsUpdated -= this.Client_GuildIntegrationsUpdate;
 		client.GuildMemberAdded -= this.Client_GuildMemberAdd;
 		client.GuildMemberRemoved -= this.Client_GuildMemberRemove;
 		client.GuildMemberUpdated -= this.Client_GuildMemberUpdate;
 		client.GuildRoleCreated -= this.Client_GuildRoleCreate;
 		client.GuildRoleUpdated -= this.Client_GuildRoleUpdate;
 		client.GuildRoleDeleted -= this.Client_GuildRoleDelete;
 		client.MessageUpdated -= this.Client_MessageUpdate;
 		client.MessageDeleted -= this.Client_MessageDelete;
 		client.MessagesBulkDeleted -= this.Client_MessageBulkDelete;
 		client.InteractionCreated -= this.Client_InteractionCreate;
 		client.ComponentInteractionCreated -= this.Client_ComponentInteractionCreate;
 		client.ContextMenuInteractionCreated -= this.Client_ContextMenuInteractionCreate;
 		client.TypingStarted -= this.Client_TypingStart;
 		client.UserSettingsUpdated -= this.Client_UserSettingsUpdate;
 		client.UserUpdated -= this.Client_UserUpdate;
 		client.VoiceStateUpdated -= this.Client_VoiceStateUpdate;
 		client.VoiceServerUpdated -= this.Client_VoiceServerUpdate;
 		client.GuildMembersChunked -= this.Client_GuildMembersChunk;
 		client.UnknownEvent -= this.Client_UnknownEvent;
 		client.MessageReactionAdded -= this.Client_MessageReactionAdd;
 		client.MessageReactionRemoved -= this.Client_MessageReactionRemove;
 		client.MessageReactionsCleared -= this.Client_MessageReactionRemoveAll;
 		client.MessageReactionRemovedEmoji -= this.Client_MessageReactionRemovedEmoji;
 		client.WebhooksUpdated -= this.Client_WebhooksUpdate;
 		client.Heartbeated -= this.Client_HeartBeated;
 		client.ApplicationCommandCreated -= this.Client_ApplicationCommandCreated;
 		client.ApplicationCommandUpdated -= this.Client_ApplicationCommandUpdated;
 		client.ApplicationCommandDeleted -= this.Client_ApplicationCommandDeleted;
 		client.GuildApplicationCommandCountUpdated -= this.Client_GuildApplicationCommandCountUpdated;
 		client.ApplicationCommandPermissionsUpdated -= this.Client_ApplicationCommandPermissionsUpdated;
 		client.GuildIntegrationCreated -= this.Client_GuildIntegrationCreated;
 		client.GuildIntegrationUpdated -= this.Client_GuildIntegrationUpdated;
 		client.GuildIntegrationDeleted -= this.Client_GuildIntegrationDeleted;
 		client.StageInstanceCreated -= this.Client_StageInstanceCreated;
 		client.StageInstanceUpdated -= this.Client_StageInstanceUpdated;
 		client.StageInstanceDeleted -= this.Client_StageInstanceDeleted;
 		client.ThreadCreated -= this.Client_ThreadCreated;
 		client.ThreadUpdated -= this.Client_ThreadUpdated;
 		client.ThreadDeleted -= this.Client_ThreadDeleted;
 		client.ThreadListSynced -= this.Client_ThreadListSynced;
 		client.ThreadMemberUpdated -= this.Client_ThreadMemberUpdated;
 		client.ThreadMembersUpdated -= this.Client_ThreadMembersUpdated;
 		client.Zombied -= this.Client_Zombied;
 		client.PayloadReceived -= this.Client_PayloadReceived;
 		client.GuildScheduledEventCreated -= this.Client_GuildScheduledEventCreated;
 		client.GuildScheduledEventUpdated -= this.Client_GuildScheduledEventUpdated;
 		client.GuildScheduledEventDeleted -= this.Client_GuildScheduledEventDeleted;
 		client.GuildScheduledEventUserAdded -= this.Client_GuildScheduledEventUserAdded; ;
 		client.GuildScheduledEventUserRemoved -= this.Client_GuildScheduledEventUserRemoved;
 		client.EmbeddedActivityUpdated -= this.Client_EmbeddedActivityUpdated;
 		client.GuildMemberTimeoutAdded -= this.Client_GuildMemberTimeoutAdded;
 		client.GuildMemberTimeoutChanged -= this.Client_GuildMemberTimeoutChanged;
 		client.GuildMemberTimeoutRemoved -= this.Client_GuildMemberTimeoutRemoved;
 	}
 
 	/// <summary>
 	/// Gets the shard id from guilds.
 	/// </summary>
 	/// <param name="id">The id.</param>
 	/// <returns>An int.</returns>
 	private int GetShardIdFromGuilds(ulong id)
 	{
 		foreach (var s in this._shards.Values)
 		{
 			if (s.GuildsInternal.TryGetValue(id, out _))
 			{
 				return s.ShardId;
 			}
 		}
 
 		return -1;
 	}
 
 	#endregion
 
 	#region Destructor
 
 	~DiscordShardedClient()
 	{
 		this.InternalStopAsync(false).GetAwaiter().GetResult();
 	}
 
 	#endregion
 }
diff --git a/DisCatSharp/DiscordConfiguration.cs b/DisCatSharp/DiscordConfiguration.cs
index 9f28db6f0..58c670f55 100644
--- a/DisCatSharp/DiscordConfiguration.cs
+++ b/DisCatSharp/DiscordConfiguration.cs
@@ -1,290 +1,290 @@
 // 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.Net;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Net.Udp;
 using DisCatSharp.Net.WebSocket;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents configuration for <see cref="DiscordClient"/> and <see cref="DiscordShardedClient"/>.
 /// </summary>
 public sealed class DiscordConfiguration
 {
 	/// <summary>
 	/// Sets the token used to identify the client.
 	/// </summary>
 	public string Token
 	{
 		internal get => this._token;
 		set
 		{
 			if (string.IsNullOrWhiteSpace(value))
 				throw new ArgumentNullException(nameof(value), "Token cannot be null, empty, or all whitespace.");
 
 			this._token = value.Trim();
 		}
 	}
 	private string _token = "";
 
 	/// <summary>
 	/// <para>Sets the type of the token used to identify the client.</para>
 	/// <para>Defaults to <see cref="TokenType.Bot"/>.</para>
 	/// </summary>
 	public TokenType TokenType { internal get; set; } = TokenType.Bot;
 
 	/// <summary>
 	/// <para>Sets the minimum logging level for messages.</para>
-	/// <para>Typically, the default value of <see cref="Microsoft.Extensions.Logging.LogLevel.Information"/> is ok for most uses.</para>
+	/// <para>Typically, the default value of <see cref="LogLevel.Information"/> is ok for most uses.</para>
 	/// </summary>
 	public LogLevel MinimumLogLevel { internal get; set; } = LogLevel.Information;
 
 	/// <summary>
 	/// Overwrites the api version.
 	/// Defaults to 10.
 	/// </summary>
 	public string ApiVersion { internal get; set; } = "10";
 
 	/// <summary>
 	/// <para>Sets whether to rely on Discord for NTP (Network Time Protocol) synchronization with the "X-Ratelimit-Reset-After" header.</para>
 	/// <para>If the system clock is unsynced, setting this to true will ensure ratelimits are synced with Discord and reduce the risk of hitting one.</para>
 	/// <para>This should only be set to false if the system clock is synced with NTP.</para>
 	/// <para>Defaults to true.</para>
 	/// </summary>
 	public bool UseRelativeRatelimit { internal get; set; } = true;
 
 	/// <summary>
 	/// <para>Allows you to overwrite the time format used by the internal debug logger.</para>
 	/// <para>Only applicable when <see cref="LoggerFactory"/> is set left at default value. Defaults to ISO 8601-like format.</para>
 	/// </summary>
 	public string LogTimestampFormat { internal get; set; } = "yyyy-MM-dd HH:mm:ss zzz";
 
 	/// <summary>
 	/// <para>Sets the member count threshold at which guilds are considered large.</para>
 	/// <para>Defaults to 250.</para>
 	/// </summary>
 	public int LargeThreshold { internal get; set; } = 250;
 
 	/// <summary>
 	/// <para>Sets whether to automatically reconnect in case a connection is lost.</para>
 	/// <para>Defaults to true.</para>
 	/// </summary>
 	public bool AutoReconnect { internal get; set; } = true;
 
 	/// <summary>
 	/// <para>Sets the ID of the shard to connect to.</para>
 	/// <para>If not sharding, or sharding automatically, this value should be left with the default value of 0.</para>
 	/// </summary>
 	public int ShardId { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets the total number of shards the bot is on. If not sharding, this value should be left with a default value of 1.</para>
 	/// <para>If sharding automatically, this value will indicate how many shards to boot. If left default for automatic sharding, the client will determine the shard count automatically.</para>
 	/// </summary>
 	public int ShardCount { internal get; set; } = 1;
 
 	/// <summary>
 	/// <para>Sets the level of compression for WebSocket traffic.</para>
 	/// <para>Disabling this option will increase the amount of traffic sent via WebSocket. Setting <see cref="GatewayCompressionLevel.Payload"/> will enable compression for READY and GUILD_CREATE payloads. Setting <see cref="GatewayCompressionLevel.Stream"/> will enable compression for the entire WebSocket stream, drastically reducing amount of traffic.</para>
 	/// <para>Defaults to <see cref="GatewayCompressionLevel.Stream"/>.</para>
 	/// </summary>
 	public GatewayCompressionLevel GatewayCompressionLevel { internal get; set; } = GatewayCompressionLevel.Stream;
 
 	/// <summary>
 	/// <para>Sets the size of the global message cache.</para>
 	/// <para>Setting this to 0 will disable message caching entirely. Defaults to 1024.</para>
 	/// </summary>
 	public int MessageCacheSize { internal get; set; } = 1024;
 
 	/// <summary>
 	/// <para>Sets the proxy to use for HTTP and WebSocket connections to Discord.</para>
 	/// <para>Defaults to null.</para>
 	/// </summary>
 	public IWebProxy Proxy { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets the timeout for HTTP requests.</para>
 	/// <para>Set to <see cref="System.Threading.Timeout.InfiniteTimeSpan"/> to disable timeouts.</para>
 	/// <para>Defaults to 20 seconds.</para>
 	/// </summary>
 	public TimeSpan HttpTimeout { internal get; set; } = TimeSpan.FromSeconds(20);
 
 	/// <summary>
 	/// <para>Defines that the client should attempt to reconnect indefinitely.</para>
 	/// <para>This is typically a very bad idea to set to <c>true</c>, as it will swallow all connection errors.</para>
 	/// <para>Defaults to false.</para>
 	/// </summary>
 	public bool ReconnectIndefinitely { internal get; set; }
 
 	/// <summary>
 	/// Sets whether the client should attempt to cache members if exclusively using unprivileged intents.
 	/// <para>
 	///     This will only take effect if there are no <see cref="DiscordIntents.GuildMembers"/> or <see cref="DiscordIntents.GuildPresences"/>
 	///     intents specified. Otherwise, this will always be overwritten to true.
 	/// </para>
 	/// <para>Defaults to true.</para>
 	/// </summary>
 	public bool AlwaysCacheMembers { internal get; set; } = true;
 
 	/// <summary>
 	/// <para>Sets the gateway intents for this client.</para>
 	/// <para>If set, the client will only receive events that they specify with intents.</para>
 	/// <para>Defaults to <see cref="DiscordIntents.AllUnprivileged"/>.</para>
 	/// </summary>
 	public DiscordIntents Intents { internal get; set; } = DiscordIntents.AllUnprivileged;
 
 	/// <summary>
 	/// <para>Sets the factory method used to create instances of WebSocket clients.</para>
-	/// <para>Use <see cref="DisCatSharp.Net.WebSocket.WebSocketClient.CreateNew(IWebProxy, IServiceProvider)"/> and equivalents on other implementations to switch out client implementations.</para>
-	/// <para>Defaults to <see cref="DisCatSharp.Net.WebSocket.WebSocketClient.CreateNew(IWebProxy, IServiceProvider)"/>.</para>
+	/// <para>Use <see cref="WebSocketClient.CreateNew"/> and equivalents on other implementations to switch out client implementations.</para>
+	/// <para>Defaults to <see cref="WebSocketClient.CreateNew"/>.</para>
 	/// </summary>
 	public WebSocketClientFactoryDelegate WebSocketClientFactory
 	{
 		internal get => this._webSocketClientFactory;
 		set
 		{
 			if (value == null)
 				throw new InvalidOperationException("You need to supply a valid WebSocket client factory method.");
 
 			this._webSocketClientFactory = value;
 		}
 	}
 	private WebSocketClientFactoryDelegate _webSocketClientFactory = WebSocketClient.CreateNew;
 
 	/// <summary>
 	/// <para>Sets the factory method used to create instances of UDP clients.</para>
 	/// <para>Use <see cref="DcsUdpClient.CreateNew"/> and equivalents on other implementations to switch out client implementations.</para>
 	/// <para>Defaults to <see cref="DcsUdpClient.CreateNew"/>.</para>
 	/// </summary>
 	public UdpClientFactoryDelegate UdpClientFactory
 	{
 		internal get => this._udpClientFactory;
 		set => this._udpClientFactory = value ?? throw new InvalidOperationException("You need to supply a valid UDP client factory method.");
 	}
 	private UdpClientFactoryDelegate _udpClientFactory = DcsUdpClient.CreateNew;
 
 	/// <summary>
 	/// <para>Sets the logger implementation to use.</para>
 	/// <para>To create your own logger, implement the <see cref="Microsoft.Extensions.Logging.ILoggerFactory"/> instance.</para>
 	/// <para>Defaults to built-in implementation.</para>
 	/// </summary>
 	public ILoggerFactory LoggerFactory { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets if the bot's status should show the mobile icon.</para>
 	/// <para>Defaults to false.</para>
 	/// </summary>
 	public bool MobileStatus { internal get; set; }
 
 	/// <summary>
 	/// <para>Whether to use canary. <see cref="UsePtb"/> has to be false.</para>
 	/// <para>Defaults to false.</para>
 	/// </summary>
 	public bool UseCanary { internal get; set; }
 
 	/// <summary>
 	/// <para>Whether to use ptb. <see cref="UseCanary"/> has to be false.</para>
 	/// <para>Defaults to false.</para>
 	/// </summary>
 	public bool UsePtb { internal get; set; }
 
 	/// <summary>
 	/// <para>Refresh full guild channel cache.</para>
 	/// <para>Defaults to false.</para>
 	/// </summary>
 	public bool AutoRefreshChannelCache { internal get; set; }
 
 	/// <summary>
 	/// <para>Do not use, this is meant for DisCatSharp Devs.</para>
 	/// <para>Defaults to null.</para>
 	/// </summary>
 	public string Override { internal get; set; }
 
 	/// <summary>
 	/// Sets your preferred API language. See <see cref="DiscordLocales" /> for valid locales.
 	/// </summary>
 	public string Locale { internal get; set; } = DiscordLocales.AMERICAN_ENGLISH;
 
 	/// <summary>
 	/// <para>Sets the service provider.</para>
 	/// <para>This allows passing data around without resorting to static members.</para>
 	/// <para>Defaults to an empty service provider.</para>
 	/// </summary>
 	public IServiceProvider ServiceProvider { internal get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
 	/// <summary>
 	/// Creates a new configuration with default values.
 	/// </summary>
 	public DiscordConfiguration()
 	{ }
 
 	/// <summary>
 	/// Utilized via Dependency Injection Pipeline
 	/// </summary>
 	/// <param name="provider"></param>
 	[ActivatorUtilitiesConstructor]
 	public DiscordConfiguration(IServiceProvider provider)
 	{
 		this.ServiceProvider = provider;
 	}
 
 	/// <summary>
 	/// Creates a clone of another discord configuration.
 	/// </summary>
 	/// <param name="other">Client configuration to clone.</param>
 	public DiscordConfiguration(DiscordConfiguration other)
 	{
 		this.Token = other.Token;
 		this.TokenType = other.TokenType;
 		this.MinimumLogLevel = other.MinimumLogLevel;
 		this.UseRelativeRatelimit = other.UseRelativeRatelimit;
 		this.LogTimestampFormat = other.LogTimestampFormat;
 		this.LargeThreshold = other.LargeThreshold;
 		this.AutoReconnect = other.AutoReconnect;
 		this.ShardId = other.ShardId;
 		this.ShardCount = other.ShardCount;
 		this.GatewayCompressionLevel = other.GatewayCompressionLevel;
 		this.MessageCacheSize = other.MessageCacheSize;
 		this.WebSocketClientFactory = other.WebSocketClientFactory;
 		this.UdpClientFactory = other.UdpClientFactory;
 		this.Proxy = other.Proxy;
 		this.HttpTimeout = other.HttpTimeout;
 		this.ReconnectIndefinitely = other.ReconnectIndefinitely;
 		this.Intents = other.Intents;
 		this.LoggerFactory = other.LoggerFactory;
 		this.MobileStatus = other.MobileStatus;
 		this.UseCanary = other.UseCanary;
 		this.UsePtb = other.UsePtb;
 		this.AutoRefreshChannelCache = other.AutoRefreshChannelCache;
 		this.ApiVersion = other.ApiVersion;
 		this.ServiceProvider = other.ServiceProvider;
 		this.Override = other.Override;
 		this.Locale = other.Locale;
 	}
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index b01b11743..aea3d05d5 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1420 +1,1420 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net.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; }
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? LastPinTimestamp
 		=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned as raw string.
 	/// </summary>
 	[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string LastPinTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets this channel's default duration for newly created threads, in minutes, to automatically archive the thread after recent activity.
 	/// </summary>
 	[JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's mention string.
 	/// </summary>
 	[JsonIgnore]
 	public string Mention
 		=> Formatter.Mention(this);
 
 	/// <summary>
 	/// Gets this channel's children. This applies only to channel categories.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordChannel> Children =>
 		!this.IsCategory
 			? throw new ArgumentException("Only channel categories contain children.")
 			: this.Guild.ChannelsInternal.Values.Where(e => e.ParentId == this.Id).ToList();
 
 	/// <summary>
 	/// Gets the list of members currently in the channel (if voice channel), or members who can see the channel (otherwise).
 	/// </summary>
 	[JsonIgnore]
 	public virtual IReadOnlyList<DiscordMember> Users =>
 		this.Guild == null
 			? throw new InvalidOperationException("Cannot query users outside of guild channels.")
 			: this.IsVoiceJoinable()
 				? this.Guild.Members.Values.Where(x => x.VoiceState?.ChannelId == this.Id).ToList()
 				: this.Guild.Members.Values.Where(x => (this.PermissionsFor(x) & Permissions.AccessChannels) == Permissions.AccessChannels).ToList();
 
 	/// <summary>
 	/// Gets whether this channel is an NSFW channel.
 	/// </summary>
 	[JsonProperty("nsfw")]
 	public bool IsNsfw { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's region id (if voice channel).
 	/// </summary>
 	[JsonProperty("rtc_region", NullValueHandling = NullValueHandling.Ignore)]
 	internal string RtcRegionId { get; set; }
 
 	/// <summary>
 	/// Gets this channel's region override (if voice channel).
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceRegion RtcRegion
 		=> this.RtcRegionId != null ? this.Discord.VoiceRegions[this.RtcRegionId] : null;
 
 
 	/// <summary>
 	/// Only sent on the resolved channels of interaction responses for application commands.
 	/// Gets the permissions of the user in this channel who invoked the command.
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions? UserPermissions { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordChannel"/> class.
 	/// </summary>
 	internal DiscordChannel()
 	{
 		this._permissionOverwritesLazy = new Lazy<IReadOnlyList<DiscordOverwrite>>(() => new ReadOnlyCollection<DiscordOverwrite>(this.PermissionOverwritesInternal));
 	}
 
 	#region Methods
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Returns a specific message
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <param name="bypassCache">Whether to bypass the message cache</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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 bypassCache = false) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& !bypassCache
 		&& this.Discord is DiscordClient dc
 		&& dc.MessageCache != null
 		&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 			? msg
 			: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Modifies the current channel.
 	/// </summary>
 	/// <param name="action">Action to perform on this channel</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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.AuditLogReason);
 	}
 
 	/// <summary>
 	/// Modifies the current forum channel.
 	/// </summary>
 	/// <param name="action">Action to perform on this channel</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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)
 			if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value))
 				throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 
 		return this.Discord.ApiClient.ModifyForumChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Template, mdl.Nsfw,
 			mdl.Parent.Map(p => p?.Id), mdl.DefaultReactionEmoji, mdl.PerUserRateLimit, mdl.PostCreateUserRateLimit,
 			mdl.DefaultAutoArchiveDuration, mdl.PermissionOverwrites, mdl.AuditLogReason);
 	}
 
 	/// <summary>
 	/// Updates the channel position when it doesn't have a category.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionInCategoryAsync"/> for moving within a category.
 	/// </summary>
 	/// <param name="position">Position the channel should be moved to.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel.</exception>
+	/// <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;
 			}
 		}
 	}
 
 	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
-	/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel, a wrong mode is given or given position is zero.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.BadRequestException"/> error.
+	/// 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="targetApplication">The target activity. Defaults to null.</param>
 	/// <param name="targetUser">The target user id. Defaults to null.</param>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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, TargetActivity? targetApplication = null, ulong? targetUser = null, string reason = null)
 		=> this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, maxAge, maxUses, targetType, targetApplication, targetUser, temporary, unique, reason);
 
 	#region Stage
 
 	/// <summary>
 	/// Opens a stage.
 	/// </summary>
 	/// <param name="topic">Topic of the stage.</param>
 	/// <param name="sendStartNotification">Whether @everyone should be notified.</param>
 	/// <param name="privacyLevel">Privacy level of the stage (Defaults to <see cref="StagePrivacyLevel.GuildOnly"/>.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <returns>Stage instance</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or <see cref="Permissions.UseVoice"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the resource does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePublicThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> or if creating a private thread the <see cref="Permissions.CreatePrivateThreads"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>. Or if <see cref="GuildFeatures.CanCreatePrivateThreads"/> is not enabled for guild. This happens, if the guild does not have <see cref="PremiumTier.TierTwo"/></exception>
+	/// <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>
 	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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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)
 	{
 		if (this.Type != ChannelType.Forum)
 			throw new NotSupportedException("Parent channel must be forum.");
 		else
 			return 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> or <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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>
 	public ForumPostTag GetForumPostTag(ulong id)
 	{
 		var tag = this.InternalAvailableTags.First(x => x.Id == id);
 		tag.Discord = this.Discord;
 		tag.ChannelId = this.Id;
 		return tag;
 	}
 
 	/// <summary>
 	/// Creates a forum channel tag.
 	/// </summary>
 	/// <param name="name">The name of the tag.</param>
 	/// <param name="emoji">The emoji of the tag. Has to be either a <see cref="DiscordGuildEmoji"/> of the current guild or a <see cref="DiscordUnicodeEmoji"/>.</param>
 	/// <param name="moderated">Whether only moderators should be able to apply this tag.</param>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the tag does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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<ForumPostTag> CreateForumPostTagAsync(string name, DiscordEmoji emoji, bool moderated = false, string reason = null)
 		=> await this.Discord.ApiClient.CreateForumTagAsync(this.Id, name, emoji, moderated, reason);
 
 	/// <summary>
 	/// Deletes a forum channel tag.
 	/// </summary>
 	/// <param name="id">The id of the tag to delete.</param>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the tag does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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 Task DeleteForumPostTag(ulong id, string reason = null)
 		=> this.Discord.ApiClient.DeleteForumTagAsync(id, this.Id, reason);
 
 	#endregion
 
 	/// <summary>
 	/// Adds a channel permission overwrite for specified role.
 	/// </summary>
 	/// <param name="role">The role to have the permission added.</param>
 	/// <param name="allow">The permissions to allow.</param>
 	/// <param name="deny">The permissions to deny.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exists or if the Member does not exists.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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="System.ArgumentException">Thrown when trying to follow a non-news channel.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> on the target channel.</exception>
+	/// <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="System.ArgumentException">Thrown when the message has already been crossposted.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">
+	/// <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="System.ArgumentException">Thrown when the channel is not a stage channel.</exception>
+	/// <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/Channel/DiscordDmChannel.cs b/DisCatSharp/Entities/Channel/DiscordDmChannel.cs
index 24e6b9e77..b81343aa2 100644
--- a/DisCatSharp/Entities/Channel/DiscordDmChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordDmChannel.cs
@@ -1,92 +1,92 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Globalization;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a direct message channel.
 /// </summary>
 public class DiscordDmChannel : DiscordChannel
 {
 	/// <summary>
 	/// Gets the recipients of this direct message.
 	/// </summary>
 	[JsonProperty("recipients", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyList<DiscordUser> Recipients { get; internal set; }
 
 	/// <summary>
 	/// Gets the hash of this channel's icon.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
 	public string IconHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the id of this direct message's creator.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong OwnerId { get; internal set; }
 
 	/// <summary>
 	/// Gets the application id of the direct message's creator if it a bot.
 	/// </summary>
 	[JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// Gets the URL of this channel's icon.
 	/// </summary>
 	[JsonIgnore]
 	public string IconUrl
 		=> !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.CHANNEL_ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.png" : null;
 
 	/// <summary>
 	/// Only use for Group DMs! Whitelisted bots only. Requires user's oauth2 access token.
 	/// </summary>
 	/// <param name="userId">The id of the user to add.</param>
 	/// <param name="accessToken">The OAuth2 access token.</param>
 	/// <param name="nickname">The nickname to give to the user.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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 AddDmRecipientAsync(ulong userId, string accessToken, string nickname)
 		=> this.Discord.ApiClient.AddGroupDmRecipientAsync(this.Id, userId, accessToken, nickname);
 
 	/// <summary>
 	/// Only use for Group DMs! Whitelisted bots only. Requires user's oauth2 access token.
 	/// </summary>
 	/// <param name="userId">The id of the User to remove.</param>
 	/// <param name="accessToken">The OAuth2 access token.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="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 RemoveDmRecipientAsync(ulong userId, string accessToken)
 		=> this.Discord.ApiClient.RemoveGroupDmRecipientAsync(this.Id, userId);
 }
diff --git a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
index 71c61516d..f847dea21 100644
--- a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
+++ b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
@@ -1,123 +1,123 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a permission overwrite for a channel.
 /// </summary>
 public class DiscordOverwrite : SnowflakeObject
 {
 	/// <summary>
 	/// Gets the type of the overwrite. Either "role" or "member".
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public OverwriteType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the allowed permission set.
 	/// </summary>
 	[JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Allowed { get; internal set; }
 
 	/// <summary>
 	/// Gets the denied permission set.
 	/// </summary>
 	[JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Denied { get; internal set; }
 
 	[JsonIgnore]
 	internal ulong ChannelId;
 
 	#region Methods
 	/// <summary>
 	/// Deletes this channel overwrite.
 	/// </summary>
 	/// <param name="reason">Reason as to why this overwrite gets deleted.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the overwrite 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.DeleteChannelPermissionAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Updates this channel overwrite.
 	/// </summary>
 	/// <param name="allow">Permissions that are allowed.</param>
 	/// <param name="deny">Permissions that are denied.</param>
 	/// <param name="reason">Reason as to why you made this change.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the overwrite 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 UpdateAsync(Permissions? allow = null, Permissions? deny = null, string reason = null)
 		=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.ChannelId, this.Id, allow ?? this.Allowed, deny ?? this.Denied, this.Type.ToString().ToLowerInvariant(), reason);
 
 	/// <summary>
 	/// Gets the DiscordMember that is affected by this overwrite.
 	/// </summary>
 	/// <returns>The DiscordMember that is affected by this overwrite</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the overwrite 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<DiscordMember> GetMemberAsync() =>
 		this.Type != OverwriteType.Member
 			? throw new ArgumentException(nameof(this.Type), "This overwrite is for a role, not a member.")
 			: await (await this.Discord.ApiClient.GetChannelAsync(this.ChannelId).ConfigureAwait(false)).Guild.GetMemberAsync(this.Id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets the DiscordRole that is affected by this overwrite.
 	/// </summary>
 	/// <returns>The DiscordRole that is affected by this overwrite</returns>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the role 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<DiscordRole> GetRoleAsync() =>
 		this.Type != OverwriteType.Role
 			? throw new ArgumentException(nameof(this.Type), "This overwrite is for a member, not a role.")
 			: (await this.Discord.ApiClient.GetChannelAsync(this.ChannelId).ConfigureAwait(false)).Guild.GetRole(this.Id);
 	#endregion
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordOverwrite"/> class.
 	/// </summary>
 	internal DiscordOverwrite()
 	{ }
 
 	/// <summary>
 	/// Checks whether given permissions are allowed, denied, or not set.
 	/// </summary>
 	/// <param name="permission">Permissions to check.</param>
 	/// <returns>Whether given permissions are allowed, denied, or not set.</returns>
 	public PermissionLevel CheckPermission(Permissions permission) =>
 		(this.Allowed & permission) != 0
 			? PermissionLevel.Allowed
 			: (this.Denied & permission) != 0 ? PermissionLevel.Denied : PermissionLevel.Unset;
 }
diff --git a/DisCatSharp/Entities/DiscordUri.cs b/DisCatSharp/Entities/DiscordUri.cs
index 95eefc038..3ef455f2d 100644
--- a/DisCatSharp/Entities/DiscordUri.cs
+++ b/DisCatSharp/Entities/DiscordUri.cs
@@ -1,161 +1,161 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Runtime.CompilerServices;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net;
 
 /// <summary>
 /// An URI in a Discord embed doesn't necessarily conform to the RFC 3986. If it uses the <c>attachment://</c>
 /// protocol, it mustn't contain a trailing slash to be interpreted correctly as an embed attachment reference by
 /// Discord.
 /// </summary>
 [JsonConverter(typeof(DiscordUriJsonConverter))]
 public class DiscordUri
 {
 	private readonly object _value;
 
 	/// <summary>
 	/// The type of this URI.
 	/// </summary>
 	public DiscordUriType Type { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUri"/> class.
 	/// </summary>
 	/// <param name="value">The value.</param>
 	internal DiscordUri(Uri value)
 	{
 		this._value = value ?? throw new ArgumentNullException(nameof(value));
 		this.Type = DiscordUriType.Standard;
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUri"/> class.
 	/// </summary>
 	/// <param name="value">The value.</param>
 	internal DiscordUri(string value)
 	{
 		if (value == null)
 			throw new ArgumentNullException(nameof(value));
 
 		if (IsStandard(value))
 		{
 			this._value = new Uri(value);
 			this.Type = DiscordUriType.Standard;
 		}
 		else
 		{
 			this._value = value;
 			this.Type = DiscordUriType.NonStandard;
 		}
 	}
 
 	/// <summary>
 	/// Whether the uri is a standard uri
 	/// </summary>
 	/// <param name="value">Uri string</param>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private static bool IsStandard(string value) => !value.StartsWith("attachment://");
 
 	/// <summary>
 	/// Returns a string representation of this DiscordUri.
 	/// </summary>
 	/// <returns>This DiscordUri, as a string.</returns>
 	public override string ToString() => this._value.ToString();
 
 	/// <summary>
-	/// Converts this DiscordUri into a canonical representation of a <see cref="System.Uri"/> if it can be represented as
+	/// Converts this DiscordUri into a canonical representation of a <see cref="Uri"/> if it can be represented as
 	/// such, throwing an exception otherwise.
 	/// </summary>
 	/// <returns>A canonical representation of this DiscordUri.</returns>
-	/// <exception cref="System.UriFormatException">If <see cref="System.Type"/> is not <see cref="DiscordUriType.Standard"/>, as
+	/// <exception cref="UriFormatException">If <see cref="System.Type"/> is not <see cref="DiscordUriType.Standard"/>, as
 	/// that would mean creating an invalid Uri, which would result in loss of data.</exception>
 	public Uri ToUri()
 		=> this.Type == DiscordUriType.Standard
 			? this._value as Uri
 			: throw new UriFormatException(
 				$@"DiscordUri ""{this._value}"" would be invalid as a regular URI, please the {nameof(this.Type)} property first.");
 
 	/// <summary>
 	/// Represents a uri json converter.
 	/// </summary>
 	internal sealed class DiscordUriJsonConverter : JsonConverter
 	{
 		/// <summary>
 		/// Writes the json.
 		/// </summary>
 		/// <param name="writer">The writer.</param>
 		/// <param name="value">The value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => writer.WriteValue((value as DiscordUri)._value);
 
 		/// <summary>
 		/// Reads the json.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="objectType">The object type.</param>
 		/// <param name="existingValue">The existing value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
 			JsonSerializer serializer)
 		{
 			var val = reader.Value;
 			return val == null
 				? null
 				: val is not string s
 				? throw new JsonReaderException("DiscordUri value invalid format! This is a bug in DisCatSharp. " +
 											  $"Include the type in your bug report: [[{reader.TokenType}]]")
 				: IsStandard(s)
 				? new DiscordUri(new Uri(s))
 				: new DiscordUri(s);
 		}
 
 		/// <summary>
 		/// Whether it can be converted.
 		/// </summary>
 		/// <param name="objectType">The object type.</param>
 		/// <returns>A bool.</returns>
 		public override bool CanConvert(Type objectType) => objectType == typeof(DiscordUri);
 	}
 }
 
 /// <summary>
 /// Represents a uri type.
 /// </summary>
 public enum DiscordUriType : byte
 {
 	/// <summary>
-	/// Represents a URI that conforms to RFC 3986, meaning it's stored internally as a <see cref="System.Uri"/> and will
+	/// Represents a URI that conforms to RFC 3986, meaning it's stored internally as a <see cref="Uri"/> and will
 	/// contain a trailing slash after the domain name.
 	/// </summary>
 	Standard,
 
 	/// <summary>
 	/// Represents a URI that does not conform to RFC 3986, meaning it's stored internally as a plain string and
 	/// should be treated as one.
 	/// </summary>
 	NonStandard
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
index 2fb98ea37..d1c3ee389 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
@@ -1,1321 +1,1321 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities;
 
 public partial class DiscordGuild
 {
 	// TODO: Rework audit logs!
 	/// <summary>
 	/// Gets audit log entries for this guild.
 	/// </summary>
 	/// <param name="limit">Maximum number of entries to fetch.</param>
 	/// <param name="byMember">Filter by member responsible.</param>
 	/// <param name="actionType">Filter by action type.</param>
 	/// <returns>A collection of requested audit log entries.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <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 : (ulong?)last, byMember?.Id, (int?)actionType).ConfigureAwait(false);
 			ac = alr.Entries.Count();
 			tc += ac;
 			if (ac > 0)
 			{
 				last = alr.Entries.Last().Id;
 				alrs.Add(alr);
 			}
 		}
 
 		var amr = alrs.SelectMany(xa => xa.Users)
 			.GroupBy(xu => xu.Id)
 			.Select(xgu => xgu.First());
 
 		foreach (var xau in amr)
 		{
 			if (this.Discord.UserCache.ContainsKey(xau.Id))
 				continue;
 
 			var xtu = new TransportUser
 			{
 				Id = xau.Id,
 				Username = xau.Username,
 				Discriminator = xau.Discriminator,
 				AvatarHash = xau.AvatarHash
 			};
 			var xu = new DiscordUser(xtu) { Discord = this.Discord };
 			xu = this.Discord.UserCache.AddOrUpdate(xu.Id, xu, (id, old) =>
 			{
 				old.Username = xu.Username;
 				old.Discriminator = xu.Discriminator;
 				old.AvatarHash = xu.AvatarHash;
 				return old;
 			});
 		}
 
 		var atgse = alrs.SelectMany(xa => xa.ScheduledEvents)
 			.GroupBy(xse => xse.Id)
 			.Select(xgse => xgse.First());
 
 		var ath = alrs.SelectMany(xa => xa.Threads)
 			.GroupBy(xt => xt.Id)
 			.Select(xgt => xgt.First());
 
 		var aig = alrs.SelectMany(xa => xa.Integrations)
 			.GroupBy(xi => xi.Id)
 			.Select(xgi => xgi.First());
 
 		var ahr = alrs.SelectMany(xa => xa.Webhooks)
 			.GroupBy(xh => xh.Id)
 			.Select(xgh => xgh.First());
 
 		var ams = amr.Select(xau => this.MembersInternal != null && this.MembersInternal.TryGetValue(xau.Id, out var member) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, GuildId = this.Id });
 		var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
 #pragma warning disable CS0219
 		Dictionary<ulong, DiscordThreadChannel> dtc = null;
 		Dictionary<ulong, DiscordIntegration> di = null;
 		Dictionary<ulong, DiscordScheduledEvent> dse = null;
 #pragma warning restore
 
 		Dictionary<ulong, DiscordWebhook> ahd = null;
 		if (ahr.Any())
 		{
 			var whr = await this.GetWebhooksAsync().ConfigureAwait(false);
 			var whs = whr.ToDictionary(xh => xh.Id, xh => xh);
 
 			var amh = ahr.Select(xah => whs.TryGetValue(xah.Id, out var webhook) ? webhook : new DiscordWebhook { Discord = this.Discord, Name = xah.Name, Id = xah.Id, AvatarHash = xah.AvatarHash, ChannelId = xah.ChannelId, GuildId = xah.GuildId, Token = xah.Token });
 			ahd = amh.ToDictionary(xh => xh.Id, xh => xh);
 		}
 
 		var acs = alrs.SelectMany(xa => xa.Entries).OrderByDescending(xa => xa.Id);
 		var entries = new List<DiscordAuditLogEntry>();
 		foreach (var xac in acs)
 		{
 			DiscordAuditLogEntry entry = null;
 			ulong t1, t2;
 			int t3, t4;
 			long t5, t6;
 			bool p1, p2;
 			switch (xac.ActionType)
 			{
 				case AuditLogActionType.Invalid:
 					break;
 
 				case AuditLogActionType.GuildUpdate:
 					entry = new DiscordAuditLogGuildEntry
 					{
 						Target = this
 					};
 
 					var entrygld = entry as DiscordAuditLogGuildEntry;
 					foreach (var xc in xac.Changes)
 					{
 						PropertyChange<DiscordChannel> GetChannelChange()
 						{
 							ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 							ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 							return new PropertyChange<DiscordChannel>
 							{
 								Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 							};
 						}
 
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrygld.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "owner_id":
 								entrygld.OwnerChange = new PropertyChange<DiscordMember>
 								{
 									Before = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.OldValueUlong, out var oldMember) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
 									After = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.NewValueUlong, out var newMember) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
 								};
 								break;
 
 							case "icon_hash":
 								entrygld.IconChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.OldValueString}.webp" : null,
 									After = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.NewValueString}.webp" : null
 								};
 								break;
 
 							case "verification_level":
 								entrygld.VerificationLevelChange = new PropertyChange<VerificationLevel>
 								{
 									Before = (VerificationLevel)(long)xc.OldValue,
 									After = (VerificationLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "afk_channel_id":
 								entrygld.AfkChannelChange = GetChannelChange();
 								break;
 
 							case "system_channel_flags":
 								entrygld.SystemChannelFlagsChange = new PropertyChange<SystemChannelFlags>()
 								{
 									Before = (SystemChannelFlags)(long)xc.OldValue,
 									After = (SystemChannelFlags)(long)xc.NewValue
 								};
 								break;
 
 							case "widget_channel_id":
 								entrygld.WidgetChannelChange = GetChannelChange();
 								break;
 
 							case "rules_channel_id":
 								entrygld.RulesChannelChange = GetChannelChange();
 								break;
 
 							case "public_updates_channel_id":
 								entrygld.PublicUpdatesChannelChange = GetChannelChange();
 								break;
 
 							case "splash_hash":
 								entrygld.SplashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.OldValueString}.webp?size=2048" : null,
 									After = xc.NewValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.NewValueString}.webp?size=2048" : null
 								};
 								break;
 
 							case "default_message_notifications":
 								entrygld.NotificationSettingsChange = new PropertyChange<DefaultMessageNotifications>
 								{
 									Before = (DefaultMessageNotifications)(long)xc.OldValue,
 									After = (DefaultMessageNotifications)(long)xc.NewValue
 								};
 								break;
 
 							case "system_channel_id":
 								entrygld.SystemChannelChange = GetChannelChange();
 								break;
 
 							case "explicit_content_filter":
 								entrygld.ExplicitContentFilterChange = new PropertyChange<ExplicitContentFilter>
 								{
 									Before = (ExplicitContentFilter)(long)xc.OldValue,
 									After = (ExplicitContentFilter)(long)xc.NewValue
 								};
 								break;
 
 							case "mfa_level":
 								entrygld.MfaLevelChange = new PropertyChange<MfaLevel>
 								{
 									Before = (MfaLevel)(long)xc.OldValue,
 									After = (MfaLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "region":
 								entrygld.RegionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "vanity_url_code":
 								entrygld.VanityUrlCodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "premium_progress_bar_enabled":
 								entrygld.PremiumProgressBarChange = new PropertyChange<bool>
 								{
 									Before = (bool)xc.OldValue,
 									After = (bool)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ChannelCreate:
 				case AuditLogActionType.ChannelDelete:
 				case AuditLogActionType.ChannelUpdate:
 					entry = new DiscordAuditLogChannelEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value) ?? new DiscordChannel { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrychn = entry as DiscordAuditLogChannelEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrychn.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrychn.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "flags":
 								entrychn.ChannelFlagsChange = new PropertyChange<ChannelFlags>()
 								{
 									Before = (ChannelFlags)(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 old_tags = xc.OldValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<ForumPostTag>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								var new_tags = xc.NewValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<ForumPostTag>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								entrychn.AvailableTagsChange = new PropertyChange<List<ForumPostTag>>
 								{
 									Before = old_tags != null ? new List<ForumPostTag>(new List<ForumPostTag>(old_tags)) : null,
 									After = new_tags != null ? new List<ForumPostTag>(new List<ForumPostTag>(new_tags)) : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.OverwriteCreate:
 				case AuditLogActionType.OverwriteDelete:
 				case AuditLogActionType.OverwriteUpdate:
 					entry = new DiscordAuditLogOverwriteEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value)?.PermissionOverwrites.FirstOrDefault(xo => xo.Id == xac.Options.Id),
 						Channel = this.GetChannel(xac.TargetId.Value)
 					};
 
 					var entryovr = entry as DiscordAuditLogOverwriteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "deny":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.DenyChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "allow":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.AllowChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "type":
 								entryovr.TypeChange = new PropertyChange<OverwriteType?>
 								{
 									Before = xc.OldValue != null ? (OverwriteType)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (OverwriteType)(long)xc.NewValue : null
 								};
 								break;
 
 							case "id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.TargetIdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? (ulong?)t1 : null,
 									After = p2 ? (ulong?)t2 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.Kick:
 					entry = new DiscordAuditLogKickEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var kickMember) ? kickMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.Prune:
 					entry = new DiscordAuditLogPruneEntry
 					{
 						Days = xac.Options.DeleteMemberDays,
 						Toll = xac.Options.MembersRemoved
 					};
 					break;
 
 				case AuditLogActionType.Ban:
 				case AuditLogActionType.Unban:
 					entry = new DiscordAuditLogBanEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var unbanMember) ? unbanMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.MemberUpdate:
 				case AuditLogActionType.MemberRoleUpdate:
 					entry = new DiscordAuditLogMemberUpdateEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var roleUpdMember) ? roleUpdMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrymbu = entry as DiscordAuditLogMemberUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "nick":
 								entrymbu.NicknameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "deaf":
 								entrymbu.DeafenChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "mute":
 								entrymbu.MuteChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "communication_disabled_until":
 								entrymbu.CommunicationDisabledUntilChange = new PropertyChange<DateTime?>
 								{
 									Before = (DateTime?)xc.OldValue,
 									After = (DateTime?)xc.NewValue
 								};
 								break;
 
 							case "$add":
 								entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							case "$remove":
 								entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.RoleCreate:
 				case AuditLogActionType.RoleDelete:
 				case AuditLogActionType.RoleUpdate:
 					entry = new DiscordAuditLogRoleUpdateEntry
 					{
 						Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryrol.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "color":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryrol.ColorChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "permissions":
 								entryrol.PermissionChange = new PropertyChange<Permissions?>
 								{
 									Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
 									After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
 								};
 								break;
 
 							case "position":
 								entryrol.PositionChange = new PropertyChange<int?>
 								{
 									Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
 								};
 								break;
 
 							case "mentionable":
 								entryrol.MentionableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "hoist":
 								entryrol.HoistChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "icon_hash":
 								entryrol.IconHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.InviteCreate:
 				case AuditLogActionType.InviteDelete:
 				case AuditLogActionType.InviteUpdate:
 					entry = new DiscordAuditLogInviteEntry();
 
 					var inv = new DiscordInvite
 					{
 						Discord = this.Discord,
 						Guild = new DiscordInviteGuild
 						{
 							Discord = this.Discord,
 							Id = this.Id,
 							Name = this.Name,
 							SplashHash = this.SplashHash
 						}
 					};
 
 					var entryinv = entry as DiscordAuditLogInviteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "max_age":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxAgeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "code":
 								inv.Code = xc.OldValueString ?? xc.NewValueString;
 
 								entryinv.CodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "temporary":
 								entryinv.TemporaryChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "inviter_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.InviterChange = new PropertyChange<DiscordMember>
 								{
 									Before = amd.TryGetValue(t1, out var propBeforeMember) ? propBeforeMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 									After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 
 								var ch = entryinv.ChannelChange.Before ?? entryinv.ChannelChange.After;
 								var cht = ch?.Type;
 								inv.Channel = new DiscordInviteChannel
 								{
 									Discord = this.Discord,
 									Id = p1 ? t1 : t2,
 									Name = ch?.Name,
 									Type = cht != null ? cht.Value : ChannelType.Unknown
 								};
 								break;
 
 							case "uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.UsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "max_uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxUsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							// TODO: Add changes for target application
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 
 					entryinv.Target = inv;
 					break;
 
 				case AuditLogActionType.WebhookCreate:
 				case AuditLogActionType.WebhookDelete:
 				case AuditLogActionType.WebhookUpdate:
 					entry = new DiscordAuditLogWebhookEntry
 					{
 						Target = ahd.TryGetValue(xac.TargetId.Value, out var webhook) ? webhook : new DiscordWebhook { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrywhk = entry as DiscordAuditLogWebhookEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "application_id": // ???
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.IdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? t1 : null,
 									After = p2 ? t2 : null
 								};
 								break;
 
 							case "name":
 								entrywhk.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 								break;
 
 							case "type": // ???
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entrywhk.TypeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "avatar_hash":
 								entrywhk.AvatarHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.EmojiCreate:
 				case AuditLogActionType.EmojiDelete:
 				case AuditLogActionType.EmojiUpdate:
 					entry = new DiscordAuditLogEmojiEntry
 					{
 						Target = this.EmojisInternal.TryGetValue(xac.TargetId.Value, out var target) ? target : new DiscordEmoji { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryemo = entry as DiscordAuditLogEmojiEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryemo.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StageInstanceCreate:
 				case AuditLogActionType.StageInstanceDelete:
 				case AuditLogActionType.StageInstanceUpdate:
 					entry = new DiscordAuditLogStageEntry
 					{
 						Target = this.StageInstancesInternal.TryGetValue(xac.TargetId.Value, out var stage) ? stage : new DiscordStageInstance { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysta = entry as DiscordAuditLogStageEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "topic":
 								entrysta.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "privacy_level":
 								entrysta.PrivacyLevelChange = new PropertyChange<StagePrivacyLevel?>
 								{
 									Before = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5) ? (StagePrivacyLevel?)t5 : null,
 									After = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6) ? (StagePrivacyLevel?)t6 : null,
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StickerCreate:
 				case AuditLogActionType.StickerDelete:
 				case AuditLogActionType.StickerUpdate:
 					entry = new DiscordAuditLogStickerEntry
 					{
 						Target = this.StickersInternal.TryGetValue(xac.TargetId.Value, out var sticker) ? sticker : new DiscordSticker { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysti = entry as DiscordAuditLogStickerEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrysti.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "description":
 								entrysti.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "tags":
 								entrysti.TagsChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "guild_id":
 								entrysti.GuildIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 							case "available":
 								entrysti.AvailabilityChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue,
 								};
 								break;
 							case "asset":
 								entrysti.AssetChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "id":
 								entrysti.IdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var oid) ? oid : null,
 									After = ulong.TryParse(xc.NewValueString, out var nid) ? nid : null
 								};
 								break;
 							case "type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.TypeChange = new PropertyChange<StickerType?>
 								{
 									Before = p1 ? (StickerType?)t5 : null,
 									After = p2 ? (StickerType?)t6 : null
 								};
 								break;
 							case "format_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.FormatChange = new PropertyChange<StickerFormat?>
 								{
 									Before = p1 ? (StickerFormat?)t5 : null,
 									After = p2 ? (StickerFormat?)t6 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 
 				case AuditLogActionType.MessageDelete:
 				case AuditLogActionType.MessageBulkDelete:
 				{
 					entry = new DiscordAuditLogMessageEntry();
 
 					var entrymsg = entry as DiscordAuditLogMessageEntry;
 
 					if (xac.Options != null)
 					{
 						entrymsg.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrymsg.MessageCount = xac.Options.Count;
 					}
 
 					if (entrymsg.Channel != null)
 					{
 						entrymsg.Target = this.Discord is DiscordClient dc
 							&& dc.MessageCache != null
 							&& dc.MessageCache.TryGet(xm => xm.Id == xac.TargetId.Value && xm.ChannelId == entrymsg.Channel.Id, out var msg)
 							? msg
 							: new DiscordMessage { Discord = this.Discord, Id = xac.TargetId.Value };
 					}
 					break;
 				}
 
 				case AuditLogActionType.MessagePin:
 				case AuditLogActionType.MessageUnpin:
 				{
 					entry = new DiscordAuditLogMessagePinEntry();
 
 					var entrypin = entry as DiscordAuditLogMessagePinEntry;
 
 					if (this.Discord is not DiscordClient dc)
 					{
 						break;
 					}
 
 					if (xac.Options != null)
 					{
 						DiscordMessage message = default;
 						dc.MessageCache?.TryGet(x => x.Id == xac.Options.MessageId && x.ChannelId == xac.Options.ChannelId, out message);
 
 						entrypin.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrypin.Message = message ?? new DiscordMessage { Id = xac.Options.MessageId, Discord = this.Discord };
 					}
 
 					if (xac.TargetId.HasValue)
 					{
 						dc.UserCache.TryGetValue(xac.TargetId.Value, out var user);
 						entrypin.Target = user ?? new DiscordUser { Id = user.Id, Discord = this.Discord };
 					}
 
 					break;
 				}
 
 				case AuditLogActionType.BotAdd:
 				{
 					entry = new DiscordAuditLogBotAddEntry();
 
 					if (!(this.Discord is DiscordClient dc && xac.TargetId.HasValue))
 					{
 						break;
 					}
 
 					dc.UserCache.TryGetValue(xac.TargetId.Value, out var bot);
 					(entry as DiscordAuditLogBotAddEntry).TargetBot = bot ?? new DiscordUser { Id = xac.TargetId.Value, Discord = this.Discord };
 
 					break;
 				}
 
 				case AuditLogActionType.MemberMove:
 					entry = new DiscordAuditLogMemberMoveEntry();
 
 					if (xac.Options == null)
 					{
 						break;
 					}
 
 					var moveentry = entry as DiscordAuditLogMemberMoveEntry;
 
 					moveentry.UserCount = xac.Options.Count;
 					moveentry.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 					break;
 
 				case AuditLogActionType.MemberDisconnect:
 					entry = new DiscordAuditLogMemberDisconnectEntry
 					{
 						UserCount = xac.Options?.Count ?? 0
 					};
 					break;
 
 				case AuditLogActionType.IntegrationCreate:
 				case AuditLogActionType.IntegrationDelete:
 				case AuditLogActionType.IntegrationUpdate:
 					entry = new DiscordAuditLogIntegrationEntry();
 
 					var integentry = entry as DiscordAuditLogIntegrationEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "type":
 								integentry.Type = new PropertyChange<string>()
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "enable_emoticons":
 								integentry.EnableEmoticons = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "expire_behavior":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 							case "expire_grace_period":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ThreadCreate:
 				case AuditLogActionType.ThreadDelete:
 				case AuditLogActionType.ThreadUpdate:
 					entry = new DiscordAuditLogThreadEntry
 					{
 						Target = this.ThreadsInternal.TryGetValue(xac.TargetId.Value, out var thread) ? thread : new DiscordThreadChannel { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrythr = entry as DiscordAuditLogThreadEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrythr.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrythr.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "archived":
 								entrythr.ArchivedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "locked":
 								entrythr.LockedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "invitable":
 								entrythr.InvitableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "auto_archive_duration":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entrythr.AutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = p1 ? (ThreadAutoArchiveDuration?)t5 : null,
 									After = p2 ? (ThreadAutoArchiveDuration?)t6 : null
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrythr.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 				case AuditLogActionType.GuildScheduledEventCreate:
 				case AuditLogActionType.GuildScheduledEventDelete:
 				case AuditLogActionType.GuildScheduledEventUpdate:
 					entry = new DiscordAuditLogGuildScheduledEventEntry
 					{
 						Target = this.ScheduledEventsInternal.TryGetValue(xac.TargetId.Value, out var scheduledEvent) ? scheduledEvent : new DiscordScheduledEvent { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryse = entry as DiscordAuditLogGuildScheduledEventEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "channel_id":
 								entryse.ChannelIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 
 							case "name":
 								entryse.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "description":
 								entryse.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "location":
 								entryse.LocationChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "privacy_level":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.PrivacyLevelChange = new PropertyChange<ScheduledEventPrivacyLevel?>
 								{
 									Before = p1 ? (ScheduledEventPrivacyLevel?)t5 : null,
 									After = p2 ? (ScheduledEventPrivacyLevel?)t6 : null
 								};
 								break;
 
 							case "entity_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.EntityTypeChange = new PropertyChange<ScheduledEventEntityType?>
 								{
 									Before = p1 ? (ScheduledEventEntityType?)t5 : null,
 									After = p2 ? (ScheduledEventEntityType?)t6 : null
 								};
 								break;
 
 							case "status":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.StatusChange = new PropertyChange<ScheduledEventStatus?>
 								{
 									Before = p1 ? (ScheduledEventStatus?)t5 : null,
 									After = p2 ? (ScheduledEventStatus?)t6 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				// TODO: Handle ApplicationCommandPermissionUpdate
 				case AuditLogActionType.ApplicationCommandPermissionUpdate:
 					break;
 
 				default:
 					this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {0} - this should be reported to library developers", (int)xac.ActionType);
 					break;
 			}
 
 			if (entry == null)
 				continue;
 
 			entry.ActionCategory = xac.ActionType switch
 			{
 				AuditLogActionType.ChannelCreate or AuditLogActionType.EmojiCreate or AuditLogActionType.InviteCreate or AuditLogActionType.OverwriteCreate or AuditLogActionType.RoleCreate or AuditLogActionType.WebhookCreate or AuditLogActionType.IntegrationCreate or AuditLogActionType.StickerCreate or AuditLogActionType.StageInstanceCreate or AuditLogActionType.ThreadCreate or AuditLogActionType.GuildScheduledEventCreate => AuditLogActionCategory.Create,
 				AuditLogActionType.ChannelDelete or AuditLogActionType.EmojiDelete or AuditLogActionType.InviteDelete or AuditLogActionType.MessageDelete or AuditLogActionType.MessageBulkDelete or AuditLogActionType.OverwriteDelete or AuditLogActionType.RoleDelete or AuditLogActionType.WebhookDelete or AuditLogActionType.IntegrationDelete or AuditLogActionType.StickerDelete or AuditLogActionType.StageInstanceDelete or AuditLogActionType.ThreadDelete or AuditLogActionType.GuildScheduledEventDelete => AuditLogActionCategory.Delete,
 				AuditLogActionType.ChannelUpdate or AuditLogActionType.EmojiUpdate or AuditLogActionType.InviteUpdate or AuditLogActionType.MemberRoleUpdate or AuditLogActionType.MemberUpdate or AuditLogActionType.OverwriteUpdate or AuditLogActionType.RoleUpdate or AuditLogActionType.WebhookUpdate or AuditLogActionType.IntegrationUpdate or AuditLogActionType.StickerUpdate or AuditLogActionType.StageInstanceUpdate or AuditLogActionType.ThreadUpdate or AuditLogActionType.GuildScheduledEventUpdate => AuditLogActionCategory.Update,
 				_ => AuditLogActionCategory.Other,
 			};
 			entry.Discord = this.Discord;
 			entry.ActionType = xac.ActionType;
 			entry.Id = xac.Id;
 			entry.Reason = xac.Reason;
 			entry.UserResponsible = amd[xac.UserId];
 			entries.Add(entry);
 		}
 
 		return new ReadOnlyCollection<DiscordAuditLogEntry>(entries);
 	}
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.cs b/DisCatSharp/Entities/Guild/DiscordGuild.cs
index 2f4cd19f1..4f7c0173e 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,2027 +1,2027 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord guild.
 /// </summary>
 public partial class DiscordGuild : SnowflakeObject, IEquatable<DiscordGuild>
 {
 	/// <summary>
 	/// Gets the guild's name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild icon's hash.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
 	public string IconHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild icon's url.
 	/// </summary>
 	[JsonIgnore]
 	public string IconUrl
 		=> !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.{(this.IconHash.StartsWith("a_") ? "gif" : "png")}?size=1024" : null;
 
 	/// <summary>
 	/// Gets the guild splash's hash.
 	/// </summary>
 	[JsonProperty("splash", NullValueHandling = NullValueHandling.Ignore)]
 	public string SplashHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild splash's url.
 	/// </summary>
 	[JsonIgnore]
 	public string SplashUrl
 	 => !string.IsNullOrWhiteSpace(this.SplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.SplashHash}.png?size=1024" : null;
 
 	/// <summary>
 	/// Gets the guild discovery splash's hash.
 	/// </summary>
 	[JsonProperty("discovery_splash", NullValueHandling = NullValueHandling.Ignore)]
 	public string DiscoverySplashHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild discovery splash's url.
 	/// </summary>
 	[JsonIgnore]
 	public string DiscoverySplashUrl
 		=> !string.IsNullOrWhiteSpace(this.DiscoverySplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILD_DISCOVERY_SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.DiscoverySplashHash}.png?size=1024" : null;
 
 	/// <summary>
 	/// Gets the preferred locale of this guild.
 	/// <para>This is used for server discovery, interactions and notices from Discord. Defaults to en-US.</para>
 	/// </summary>
 	[JsonProperty("preferred_locale", NullValueHandling = NullValueHandling.Ignore)]
 	public string PreferredLocale { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the guild's owner.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong OwnerId { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's owner.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMember Owner
 		=> this.Members.TryGetValue(this.OwnerId, out var owner)
 			? owner
 			: this.Discord.ApiClient.GetGuildMemberAsync(this.Id, this.OwnerId).ConfigureAwait(false).GetAwaiter().GetResult();
 
 	/// <summary>
 	/// Gets permissions for the user in the guild (does not include channel overrides)
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions? Permissions { get; set; }
 
 	/// <summary>
 	/// Gets the guild's voice region ID.
 	/// </summary>
 	[JsonProperty("region", NullValueHandling = NullValueHandling.Ignore)]
 	internal string VoiceRegionId { get; set; }
 
 	/// <summary>
 	/// Gets the guild's voice region.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceRegion VoiceRegion
 		=> this.Discord.VoiceRegions[this.VoiceRegionId];
 
 	/// <summary>
 	/// Gets the guild's AFK voice channel ID.
 	/// </summary>
 	[JsonProperty("afk_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong AfkChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the guild's AFK voice channel.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel AfkChannel
 		=> this.GetChannel(this.AfkChannelId);
 
 	/// <summary>
 	/// List of <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>.
 	/// Null if DisCatSharp.ApplicationCommands is not used or no guild commands are registered.
 	/// </summary>
 	[JsonIgnore]
 	public ReadOnlyCollection<DiscordApplicationCommand> RegisteredApplicationCommands
 		=> new(this.InternalRegisteredApplicationCommands);
 	[JsonIgnore]
 	internal List<DiscordApplicationCommand> InternalRegisteredApplicationCommands { get; set; } = null;
 
 	/// <summary>
 	/// Gets the guild's AFK timeout.
 	/// </summary>
 	[JsonProperty("afk_timeout", NullValueHandling = NullValueHandling.Ignore)]
 	public int AfkTimeout { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's verification level.
 	/// </summary>
 	[JsonProperty("verification_level", NullValueHandling = NullValueHandling.Ignore)]
 	public VerificationLevel VerificationLevel { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's default notification settings.
 	/// </summary>
 	[JsonProperty("default_message_notifications", NullValueHandling = NullValueHandling.Ignore)]
 	public DefaultMessageNotifications DefaultMessageNotifications { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's explicit content filter settings.
 	/// </summary>
 	[JsonProperty("explicit_content_filter")]
 	public ExplicitContentFilter ExplicitContentFilter { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's nsfw level.
 	/// </summary>
 	[JsonProperty("nsfw_level")]
 	public NsfwLevel NsfwLevel { get; internal set; }
 
 	/// <summary>
 	/// Gets the system channel id.
 	/// </summary>
 	[JsonProperty("system_channel_id", NullValueHandling = NullValueHandling.Include)]
 	internal ulong? SystemChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the channel where system messages (such as boost and welcome messages) are sent.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel SystemChannel => this.SystemChannelId.HasValue
 		? this.GetChannel(this.SystemChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the settings for this guild's system channel.
 	/// </summary>
 	[JsonProperty("system_channel_flags")]
 	public SystemChannelFlags SystemChannelFlags { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild's widget is enabled.
 	/// </summary>
 	[JsonProperty("widget_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? WidgetEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets the widget channel id.
 	/// </summary>
 	[JsonProperty("widget_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong? WidgetChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the widget channel for this guild.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel WidgetChannel => this.WidgetChannelId.HasValue
 		? this.GetChannel(this.WidgetChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the rules channel id.
 	/// </summary>
 	[JsonProperty("rules_channel_id")]
 	internal ulong? RulesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the rules channel for this guild.
 	/// <para>This is only available if the guild is considered "discoverable".</para>
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel RulesChannel => this.RulesChannelId.HasValue
 		? this.GetChannel(this.RulesChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the public updates channel id.
 	/// </summary>
 	[JsonProperty("public_updates_channel_id")]
 	internal ulong? PublicUpdatesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the public updates channel (where admins and moderators receive messages from Discord) for this guild.
 	/// <para>This is only available if the guild is considered "discoverable".</para>
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel PublicUpdatesChannel => this.PublicUpdatesChannelId.HasValue
 		? this.GetChannel(this.PublicUpdatesChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the application id of this guild if it is bot created.
 	/// </summary>
 	[JsonProperty("application_id")]
 	public ulong? ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// Gets a collection of this guild's roles.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordRole> Roles => new ReadOnlyConcurrentDictionary<ulong, DiscordRole>(this.RolesInternal);
 
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordRole> RolesInternal;
 
 	/// <summary>
 	/// Gets a collection of this guild's stickers.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordSticker> Stickers => new ReadOnlyConcurrentDictionary<ulong, DiscordSticker>(this.StickersInternal);
 
 	[JsonProperty("stickers", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordSticker> StickersInternal;
 
 	/// <summary>
 	/// Gets a collection of this guild's emojis.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordEmoji> Emojis => new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(this.EmojisInternal);
 
 	[JsonProperty("emojis", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordEmoji> EmojisInternal;
 
 	/// <summary>
 	/// Gets a collection of this guild's features.
 	/// </summary>
 	[JsonProperty("features", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyList<string> RawFeatures { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's features.
 	/// </summary>
 	[JsonIgnore]
 	public GuildFeatures Features => new(this);
 
 	/// <summary>
 	/// Gets the required multi-factor authentication level for this guild.
 	/// </summary>
 	[JsonProperty("mfa_level", NullValueHandling = NullValueHandling.Ignore)]
 	public MfaLevel MfaLevel { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's join date.
 	/// </summary>
 	[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset JoinedAt { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild is considered to be a large guild.
 	/// </summary>
 	[JsonProperty("large", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsLarge { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild is unavailable.
 	/// </summary>
 	[JsonProperty("unavailable", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsUnavailable { get; internal set; }
 
 	/// <summary>
 	/// Gets the total number of members in this guild.
 	/// </summary>
 	[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int MemberCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of members allowed for this guild.
 	/// </summary>
 	[JsonProperty("max_members")]
 	public int? MaxMembers { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of presences allowed for this guild.
 	/// </summary>
 	[JsonProperty("max_presences")]
 	public int? MaxPresences { get; internal set; }
 
 	/// <summary>
 	/// Gets the approximate number of members in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having withCounts set to true.
 	/// </summary>
 	[JsonProperty("approximate_member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ApproximateMemberCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the approximate number of presences in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having withCounts set to true.
 	/// </summary>
 	[JsonProperty("approximate_presence_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ApproximatePresenceCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of users allowed per video channel.
 	/// </summary>
 	[JsonProperty("max_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MaxVideoChannelUsers { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of users allowed per video stage channel.
 	/// </summary>
 	[JsonProperty("max_stage_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MaxStageVideoChannelUsers { get; internal set; }
 
 	/// <summary>
 	/// Gets a dictionary of all the voice states for this guilds. The key for this dictionary is the ID of the user
 	/// the voice state corresponds to.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordVoiceState> VoiceStates => new ReadOnlyConcurrentDictionary<ulong, DiscordVoiceState>(this.VoiceStatesInternal);
 
 	[JsonProperty("voice_states", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordVoiceState> VoiceStatesInternal;
 
 	/// <summary>
 	/// Gets a dictionary of all the members that belong to this guild. The dictionary's key is the member ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordMember> Members => new ReadOnlyConcurrentDictionary<ulong, DiscordMember>(this.MembersInternal);
 
 	[JsonProperty("members", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordMember> MembersInternal;
 
 	/// <summary>
 	/// Gets a dictionary of all the channels associated with this guild. The dictionary's key is the channel ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordChannel> Channels => new ReadOnlyConcurrentDictionary<ulong, DiscordChannel>(this.ChannelsInternal);
 
 	[JsonProperty("channels", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordChannel> ChannelsInternal;
 
 	internal ConcurrentDictionary<string, DiscordInvite> Invites;
 
 	/// <summary>
 	/// Gets a dictionary of all the active threads associated with this guild the user has permission to view. The dictionary's key is the channel ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordThreadChannel> Threads { get; internal set; }
 
 	[JsonProperty("threads", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordThreadChannel> ThreadsInternal = new();
 
 	/// <summary>
 	/// Gets a dictionary of all active stage instances. The dictionary's key is the stage ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordStageInstance> StageInstances { get; internal set; }
 
 	[JsonProperty("stage_instances", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordStageInstance> StageInstancesInternal = new();
 
 	/// <summary>
 	/// Gets a dictionary of all scheduled events.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordScheduledEvent> ScheduledEvents { get; internal set; }
 
 	[JsonProperty("guild_scheduled_events", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordScheduledEvent> ScheduledEventsInternal = new();
 
 	/// <summary>
 	/// Gets the guild member for current user.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMember CurrentMember
 		=> this._currentMemberLazy.Value;
 
 	[JsonIgnore]
 	private readonly Lazy<DiscordMember> _currentMemberLazy;
 
 	/// <summary>
 	/// Gets the @everyone role for this guild.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordRole EveryoneRole
 		=> this.GetRole(this.Id);
 
 	[JsonIgnore]
 	internal bool IsOwnerInternal;
 
 	/// <summary>
 	/// Gets whether the current user is the guild's owner.
 	/// </summary>
 	[JsonProperty("owner", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsOwner
 	{
 		get => this.IsOwnerInternal || this.OwnerId == this.Discord.CurrentUser.Id;
 		internal set => this.IsOwnerInternal = value;
 	}
 
 	/// <summary>
 	/// Gets the vanity URL code for this guild, when applicable.
 	/// </summary>
 	[JsonProperty("vanity_url_code")]
 	public string VanityUrlCode { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild description, when applicable.
 	/// </summary>
 	[JsonProperty("description")]
 	public string Description { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's banner hash, when applicable.
 	/// </summary>
 	[JsonProperty("banner")]
 	public string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's banner in url form.
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
 	/// <summary>
 	/// Whether this guild has the community feature enabled.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCommunity => this.Features.HasCommunityEnabled;
 
 	/// <summary>
 	/// Whether this guild has enabled the welcome screen.
 	/// </summary>
 	[JsonIgnore]
 	public bool HasWelcomeScreen => this.Features.HasWelcomeScreenEnabled;
 
 	/// <summary>
 	/// Whether this guild has enabled membership screening.
 	/// </summary>
 	[JsonIgnore]
 	public bool HasMemberVerificationGate => this.Features.HasMembershipScreeningEnabled;
 
 	/// <summary>
 	/// Gets this guild's premium tier (Nitro boosting).
 	/// </summary>
 	[JsonProperty("premium_tier")]
 	public PremiumTier PremiumTier { get; internal set; }
 
 	/// <summary>
 	/// Gets the amount of members that boosted this guild.
 	/// </summary>
 	[JsonProperty("premium_subscription_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? PremiumSubscriptionCount { get; internal set; }
 
 	/// <summary>
 	/// Whether the premium progress bar is enabled.
 	/// </summary>
 	[JsonProperty("premium_progress_bar_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool PremiumProgressBarEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild is designated as NSFW.
 	/// </summary>
 	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsNsfw { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's hub type, if applicable.
 	/// </summary>
 	[JsonProperty("hub_type", NullValueHandling = NullValueHandling.Ignore)]
 	public HubType HubType { get; internal set; }
 
 	/// <summary>
 	/// Gets a dictionary of all by position ordered channels associated with this guild. The dictionary's key is the channel ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordChannel> OrderedChannels => new ReadOnlyDictionary<ulong, DiscordChannel>(this.InternalSortChannels());
 
 	/// <summary>
 	/// Sorts the channels.
 	/// </summary>
 	private Dictionary<ulong, DiscordChannel> InternalSortChannels()
 	{
 		Dictionary<ulong, DiscordChannel> keyValuePairs = new();
 		var ochannels = this.GetOrderedChannels();
 		foreach (var ochan in ochannels)
 		{
 			if (ochan.Key != 0)
 				keyValuePairs.Add(ochan.Key, this.GetChannel(ochan.Key));
 			foreach (var chan in ochan.Value)
 				keyValuePairs.Add(chan.Id, chan);
 		}
 		return keyValuePairs;
 	}
 
 	/// <summary>
 	/// Gets an ordered <see cref="DiscordChannel"/> list out of the channel cache.
 	/// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
 	/// Ignore the 0 key here, because that indicates that this is the "has no category" list.
 	/// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <returns>A ordered list of categories with its channels</returns>
 	public Dictionary<ulong, List<DiscordChannel>> GetOrderedChannels()
 	{
 		IReadOnlyList<DiscordChannel> rawChannels = this.ChannelsInternal.Values.ToList();
 
 		Dictionary<ulong, List<DiscordChannel>> orderedChannels = new()
 		{
 			{ 0, new List<DiscordChannel>() }
 		};
 
 		foreach (var channel in rawChannels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
 		{
 			orderedChannels.Add(channel.Id, new List<DiscordChannel>());
 		}
 
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News || c.Type == ChannelType.Forum)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News || c.Type == ChannelType.Forum)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 
 		return orderedChannels;
 	}
 
 	/// <summary>
 	/// Gets an ordered <see cref="DiscordChannel"/> list.
 	/// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
 	/// Ignore the 0 key here, because that indicates that this is the "has no category" list.
 	/// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <returns>A ordered list of categories with its channels</returns>
 	public async Task<Dictionary<ulong, List<DiscordChannel>>> GetOrderedChannelsAsync()
 	{
 		var rawChannels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
 		Dictionary<ulong, List<DiscordChannel>> orderedChannels = new()
 		{
 			{ 0, new List<DiscordChannel>() }
 		};
 
 		foreach (var channel in rawChannels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
 		{
 			orderedChannels.Add(channel.Id, new List<DiscordChannel>());
 		}
 
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News || c.Type == ChannelType.Forum)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News || c.Type == ChannelType.Forum)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 
 		return orderedChannels;
 	}
 
 	/// <summary>
 	/// Whether it is synced.
 	/// </summary>
 	[JsonIgnore]
 	internal bool IsSynced { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordGuild"/> class.
 	/// </summary>
 	internal DiscordGuild()
 	{
 		this._currentMemberLazy = new Lazy<DiscordMember>(() => this.MembersInternal != null && this.MembersInternal.TryGetValue(this.Discord.CurrentUser.Id, out var member) ? member : null);
 		this.Invites = new ConcurrentDictionary<string, DiscordInvite>();
 		this.Threads = new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannel>(this.ThreadsInternal);
 		this.StageInstances = new ReadOnlyConcurrentDictionary<ulong, DiscordStageInstance>(this.StageInstancesInternal);
 		this.ScheduledEvents = new ReadOnlyConcurrentDictionary<ulong, DiscordScheduledEvent>(this.ScheduledEventsInternal);
 	}
 
 	#region Guild Methods
 
 	/// <summary>
 	/// Searches the current guild for members who's display name start with the specified name.
 	/// </summary>
 	/// <param name="name">The name to search for.</param>
 	/// <param name="limit">The maximum amount of members to return. Max 1000. Defaults to 1.</param>
 	/// <returns>The members found, if any.</returns>
 	public Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(string name, int? limit = 1)
 		=> this.Discord.ApiClient.SearchMembersAsync(this.Id, name, limit);
 
 	/// <summary>
 	/// Adds a new member to this guild
 	/// </summary>
 	/// <param name="user">User to add</param>
 	/// <param name="accessToken">User's access token (OAuth2)</param>
 	/// <param name="nickname">new nickname</param>
 	/// <param name="roles">new roles</param>
 	/// <param name="muted">whether this user has to be muted</param>
 	/// <param name="deaf">whether this user has to be deafened</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite" /> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="accessToken"/> is not found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite" /> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="accessToken"/> is not found.</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 AddMemberAsync(DiscordUser user, string accessToken, string nickname = null, IEnumerable<DiscordRole> roles = null,
 		bool muted = false, bool deaf = false)
 		=> this.Discord.ApiClient.AddGuildMemberAsync(this.Id, user.Id, accessToken, nickname, roles, muted, deaf);
 
 	/// <summary>
 	/// Deletes this guild. Requires the caller to be the owner of the guild.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client is not the owner of the guild.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client is not the owner of the guild.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync()
 		=> this.Discord.ApiClient.DeleteGuildAsync(this.Id);
 
 	/// <summary>
 	/// Enables the mfa requirement for this guild.
 	/// </summary>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user is not the guilds owner.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the current user is not the guilds owner.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task EnableMfaAsync(string reason = null)
 		=> this.IsOwner ? this.Discord.ApiClient.EnableGuildMfaAsync(this.Id, reason) : throw new Exception("The current user does not own the guild.");
 
 	/// <summary>
 	/// Disables the mfa requirement for this guild.
 	/// </summary>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user is not the guilds owner.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the current user is not the guilds owner.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 
 	public Task DisableMfaAsync(string reason = null)
 		=> this.IsOwner ? this.Discord.ApiClient.DisableGuildMfaAsync(this.Id, reason) : throw new Exception("The current user does not own the guild.");
 
 	/// <summary>
 	/// Modifies this guild.
 	/// </summary>
 	/// <param name="action">Action to perform on this guild.</param>
 	/// <returns>The modified guild object.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordGuild> ModifyAsync(Action<GuildEditModel> action)
 	{
 		var mdl = new GuildEditModel();
 		action(mdl);
 
 		var afkChannelId = mdl.PublicUpdatesChannel
 			.MapOrNull<ulong?>(c => c.Type != ChannelType.Voice
 				? throw new ArgumentException("AFK channel needs to be a text channel.")
 				: c.Id);
 
 		static Optional<ulong?> ChannelToId(Optional<DiscordChannel> ch, string name)
 			=> ch.MapOrNull<ulong?>(c => c.Type != ChannelType.Text && c.Type != ChannelType.News
 				? throw new ArgumentException($"{name} channel needs to be a text channel.")
 				: c.Id);
 
 		var rulesChannelId = ChannelToId(mdl.RulesChannel, "Rules");
 		var publicUpdatesChannelId = ChannelToId(mdl.PublicUpdatesChannel, "Public updates");
 		var systemChannelId = ChannelToId(mdl.SystemChannel, "System");
 
 		var iconb64 = ImageTool.Base64FromStream(mdl.Icon);
 		var splashb64 = ImageTool.Base64FromStream(mdl.Splash);
 		var bannerb64 = ImageTool.Base64FromStream(mdl.Banner);
 		var discoverySplash64 = ImageTool.Base64FromStream(mdl.DiscoverySplash);
 
 		return await this.Discord.ApiClient.ModifyGuildAsync(this.Id, mdl.Name,
 			mdl.VerificationLevel, mdl.DefaultMessageNotifications, mdl.MfaLevel, mdl.ExplicitContentFilter,
 			afkChannelId, mdl.AfkTimeout, iconb64, mdl.Owner.Map(e => e.Id), splashb64,
 			systemChannelId, mdl.SystemChannelFlags, publicUpdatesChannelId, rulesChannelId,
 			mdl.Description, bannerb64, discoverySplash64, mdl.PreferredLocale, mdl.PremiumProgressBarEnabled, mdl.AuditLogReason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Modifies the community settings async.
 	/// This sets <see cref="VerificationLevel.High"/> if not highest and <see cref="ExplicitContentFilter.AllMembers"/>.
 	/// </summary>
 	/// <param name="enabled">If true, enable <see cref="GuildFeatures.HasCommunityEnabled"/>.</param>
 	/// <param name="rulesChannel">The rules channel.</param>
 	/// <param name="publicUpdatesChannel">The public updates channel.</param>
 	/// <param name="preferredLocale">The preferred locale. Defaults to en-US.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="defaultMessageNotifications">The default message notifications. Defaults to <see cref="DefaultMessageNotifications.MentionsOnly"/></param>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.Administrator"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.Administrator"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordGuild> ModifyCommunitySettingsAsync(bool enabled, DiscordChannel rulesChannel = null, DiscordChannel publicUpdatesChannel = null, string preferredLocale = "en-US", string description = null, DefaultMessageNotifications defaultMessageNotifications = DefaultMessageNotifications.MentionsOnly, string reason = null)
 	{
 		var verificationLevel = this.VerificationLevel;
 		if (this.VerificationLevel != VerificationLevel.Highest)
 		{
 			verificationLevel = VerificationLevel.High;
 		}
 
 		var explicitContentFilter = ExplicitContentFilter.AllMembers;
 
 		static Optional<ulong?> ChannelToId(DiscordChannel ch, string name)
 			=> ch == null ? null :
 				ch.Type != ChannelType.Text && ch.Type != ChannelType.News
 					? throw new ArgumentException($"{name} channel needs to be a text channel.")
 					: ch.Id;
 
 		var rulesChannelId = ChannelToId(rulesChannel, "Rules");
 		var publicUpdatesChannelId = ChannelToId(publicUpdatesChannel, "Public updates");
 
 		List<string> features = new();
 		var rfeatures = this.RawFeatures.ToList();
 		if (!this.RawFeatures.Contains("COMMUNITY") && enabled)
 		{
 			rfeatures.Add("COMMUNITY");
 		}
 		else if (this.RawFeatures.Contains("COMMUNITY") && !enabled)
 		{
 			rfeatures.Remove("COMMUNITY");
 		}
 		features = rfeatures;
 
 		return await this.Discord.ApiClient.ModifyGuildCommunitySettingsAsync(this.Id, features, rulesChannelId, publicUpdatesChannelId, preferredLocale, description, defaultMessageNotifications, explicitContentFilter, verificationLevel, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Enables invites for the guild.
 	/// </summary>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordGuild> EnableInvitesAsync(string reason = null)
 	{
 		List<string> features = new();
 		var rfeatures = this.RawFeatures.ToList();
 		if (this.Features.InvitesDisabled)
 			rfeatures.Remove("INVITES_DISABLED");
 		features = rfeatures;
 
 		return await this.Discord.ApiClient.ModifyGuildFeaturesAsync(this.Id, features, reason);
 	}
 
 	/// <summary>
 	/// Disables invites for the guild.
 	/// </summary>
 	/// <param name="reason"></param>
 	/// <returns></returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordGuild> DisableInvitesAsync(string reason = null)
 	{
 		List<string> features = new();
 		var rfeatures = this.RawFeatures.ToList();
 		if (!this.Features.InvitesDisabled)
 			rfeatures.Add("INVITES_DISABLED");
 		features = rfeatures;
 
 		return await this.Discord.ApiClient.ModifyGuildFeaturesAsync(this.Id, features, reason);
 	}
 
 	/// <summary>
 	/// Timeout a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to timeout.</param>
 	/// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 TimeoutAsync(ulong memberId, DateTimeOffset until, string reason = null)
 		=> until.Subtract(DateTimeOffset.UtcNow).Days > 28
 			? throw new ArgumentException("Timeout can not be longer than 28 days")
 			: this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, memberId, until, reason);
 
 	/// <summary>
 	/// Timeout a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to timeout.</param>
 	/// <param name="until">The timespan to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 TimeoutAsync(ulong memberId, TimeSpan until, string reason = null)
 		=> this.TimeoutAsync(memberId, DateTimeOffset.UtcNow + until, reason);
 
 	/// <summary>
 	/// Timeout a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to timeout.</param>
 	/// <param name="until">The datetime to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 TimeoutAsync(ulong memberId, DateTime until, string reason = null)
 		=> this.TimeoutAsync(memberId, until.ToUniversalTime() - DateTime.UtcNow, reason);
 
 	/// <summary>
 	/// Removes the timeout from a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to remove the timeout from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 RemoveTimeoutAsync(ulong memberId, string reason = null)
 		=> this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, memberId, null, reason);
 
 	/// <summary>
 	/// Bans a specified member from this guild.
 	/// </summary>
 	/// <param name="member">Member to ban.</param>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 BanMemberAsync(DiscordMember member, int deleteMessageDays = 0, string reason = null)
 		=> this.Discord.ApiClient.CreateGuildBanAsync(this.Id, member.Id, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Bans a specified user by ID. This doesn't require the user to be in this guild.
 	/// </summary>
 	/// <param name="userId">ID of the user to ban.</param>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 BanMemberAsync(ulong userId, int deleteMessageDays = 0, string reason = null)
 		=> this.Discord.ApiClient.CreateGuildBanAsync(this.Id, userId, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Unbans a user from this guild.
 	/// </summary>
 	/// <param name="user">User to unban.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user 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 UnbanMemberAsync(DiscordUser user, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user.Id, reason);
 
 	/// <summary>
 	/// Unbans a user by ID.
 	/// </summary>
 	/// <param name="userId">ID of the user to unban.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user 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 UnbanMemberAsync(ulong userId, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, userId, reason);
 
 	/// <summary>
 	/// Leaves this guild.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task LeaveAsync()
 		=> this.Discord.ApiClient.LeaveGuildAsync(this.Id);
 
 	/// <summary>
 	/// Gets the bans for this guild, allowing for pagination.
 	/// </summary>
 	/// <param name="limit">Maximum number of bans to fetch. Max 1000. Defaults to 1000.</param>
 	/// <param name="before">The Id of the user before which to fetch the bans. Overrides <paramref name="after"/> if both are present.</param>
 	/// <param name="after">The Id of the user after which to fetch the bans.</param>
 	/// <returns>Collection of bans in this guild in ascending order by user id.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordBan>> GetBansAsync(int? limit = null, ulong? before = null, ulong? after = null)
 		=> this.Discord.ApiClient.GetGuildBansAsync(this.Id, limit, before, after);
 
 	/// <summary>
 	/// Gets a ban for a specific user.
 	/// </summary>
 	/// <param name="userId">The Id of the user to get the ban for.</param>
 	/// <returns>The requested ban object.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
+	/// <exception cref="NotFoundException">Thrown when the specified user is not banned.</exception>
 	public Task<DiscordBan> GetBanAsync(ulong userId)
 		=> this.Discord.ApiClient.GetGuildBanAsync(this.Id, userId);
 
 	/// <summary>
 	/// Gets a ban for a specific user.
 	/// </summary>
 	/// <param name="user">The user to get the ban for.</param>
 	/// <returns>The requested ban object.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
+	/// <exception cref="NotFoundException">Thrown when the specified user is not banned.</exception>
 	public Task<DiscordBan> GetBanAsync(DiscordUser user)
 		=> this.GetBanAsync(user.Id);
 
 	#region Scheduled Events
 
 	/// <summary>
 	/// Creates a scheduled event.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="scheduledStartTime">The scheduled start time.</param>
 	/// <param name="scheduledEndTime">The scheduled end time.</param>
 	/// <param name="channel">The channel.</param>
 	/// <param name="metadata">The metadata.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="coverImage">The cover image.</param>
 	/// <param name="reason">The reason.</param>
 	/// <returns>A scheduled event.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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, DateTimeOffset? scheduledEndTime = null, DiscordChannel channel = null, DiscordScheduledEventEntityMetadata metadata = null, string description = null, ScheduledEventEntityType type = ScheduledEventEntityType.StageInstance, Optional<Stream> coverImage = default, string reason = null)
 	{
 		var coverb64 = ImageTool.Base64FromStream(coverImage);
 		return await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, type == ScheduledEventEntityType.External ? null : channel?.Id, type == ScheduledEventEntityType.External ? metadata : null, name, scheduledStartTime, scheduledEndTime.HasValue && type == ScheduledEventEntityType.External ? scheduledEndTime.Value : null, description, type, coverb64, reason);
 	}
 
 	/// <summary>
 	/// Creates a scheduled event with type <see cref="ScheduledEventEntityType.External"/>.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="scheduledStartTime">The scheduled start time.</param>
 	/// <param name="scheduledEndTime">The scheduled end time.</param>
 	/// <param name="location">The location of the external event.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="coverImage">The cover image.</param>
 	/// <param name="reason">The reason.</param>
 	/// <returns>A scheduled event.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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> CreateExternalScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset scheduledEndTime, string location, string description = null, Optional<Stream> coverImage = default, string reason = null)
 	{
 		var coverb64 = ImageTool.Base64FromStream(coverImage);
 		return await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, null, new DiscordScheduledEventEntityMetadata(location), name, scheduledStartTime, scheduledEndTime, description, ScheduledEventEntityType.External, coverb64, reason);
 	}
 
 
 	/// <summary>
 	/// Gets a specific scheduled events.
 	/// </summary>
 	/// <param name="scheduledEventId">The Id of the event to get.</param>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	/// <returns>A scheduled event.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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> GetScheduledEventAsync(ulong scheduledEventId, bool? withUserCount = null)
 		=> this.ScheduledEventsInternal.TryGetValue(scheduledEventId, out var ev) ? ev : await this.Discord.ApiClient.GetGuildScheduledEventAsync(this.Id, scheduledEventId, withUserCount);
 
 	/// <summary>
 	/// Gets a specific scheduled events.
 	/// </summary>
 	/// <param name="scheduledEvent">The event to get.</param>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	/// <returns>A scheduled event.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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> GetScheduledEventAsync(DiscordScheduledEvent scheduledEvent, bool? withUserCount = null)
 		=> await this.GetScheduledEventAsync(scheduledEvent.Id, withUserCount);
 
 	/// <summary>
 	/// Gets the guilds scheduled events.
 	/// </summary>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	/// <returns>A list of the guilds scheduled events.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> GetScheduledEventsAsync(bool? withUserCount = null)
 		=> await this.Discord.ApiClient.ListGuildScheduledEventsAsync(this.Id, withUserCount);
 	#endregion
 
 	/// <summary>
 	/// Creates a new text channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="topic">Topic of the channel.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
 	/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordChannel> CreateTextChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, ThreadAutoArchiveDuration defaultAutoArchiveDuration = ThreadAutoArchiveDuration.OneDay, string reason = null)
 		=> this.CreateChannelAsync(name, ChannelType.Text, parent, topic, null, null, overwrites, nsfw, perUserRateLimit, null, defaultAutoArchiveDuration, reason);
 
 	/// <summary>
 	/// Creates a new forum channel in this guild.
 	/// <note type="note">The field template is not yet released, so it won't applied.</note>
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="topic">Topic of the channel.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
 	/// <param name="defaultReactionEmoji">The default reaction emoji for posts.</param>
 	/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 	/// <param name="postCreateUserRateLimit">Slow mode timeout for user post creations.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission or the guild does not have the forum channel feature.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission or the guild does not have the forum channel feature.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordChannel> CreateForumChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<ForumReactionEmoji> defaultReactionEmoji = default, Optional<int?> perUserRateLimit = default, Optional<int?> postCreateUserRateLimit = default, ThreadAutoArchiveDuration defaultAutoArchiveDuration = ThreadAutoArchiveDuration.OneDay, string reason = null)
 		 => this.Discord.ApiClient.CreateForumChannelAsync(this.Id, name, parent?.Id, topic, null, nsfw, defaultReactionEmoji, perUserRateLimit, postCreateUserRateLimit, defaultAutoArchiveDuration, overwrites, reason);
 
 	/// <summary>
 	/// Creates a new channel category in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new category.</param>
 	/// <param name="overwrites">Permission overwrites for this category.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel category.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordChannel> CreateChannelCategoryAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 		=> this.CreateChannelAsync(name, ChannelType.Category, null, Optional.None, null, null, overwrites, null, Optional.None, null, null, reason);
 
 	/// <summary>
 	/// Creates a new stage channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new stage channel.</param>
 	/// <param name="overwrites">Permission overwrites for this stage channel.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created stage channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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="NotSupportedException">Thrown when the guilds has not enabled community.</exception>
 	public Task<DiscordChannel> CreateStageChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 		=> this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.Stage, null, Optional.None, null, null, overwrites, null, Optional.None, null, null, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a stage channel.");
 
 	/// <summary>
 	/// Creates a new news channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new news channel.</param>
 	/// <param name="overwrites">Permission overwrites for this news channel.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created news channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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="NotSupportedException">Thrown when the guilds has not enabled community.</exception>
 	public Task<DiscordChannel> CreateNewsChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null, ThreadAutoArchiveDuration defaultAutoArchiveDuration = ThreadAutoArchiveDuration.OneDay)
 		=> this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.News, null, Optional.None, null, null, overwrites, null, Optional.None, null, defaultAutoArchiveDuration, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a news channel.");
 
 	/// <summary>
 	/// Creates a new voice channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="bitrate">Bitrate of the channel.</param>
 	/// <param name="userLimit">Maximum number of users in the channel.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="qualityMode">Video quality mode of the channel.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordChannel> CreateVoiceChannelAsync(string name, DiscordChannel parent = null, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, VideoQualityMode? qualityMode = null, string reason = null)
 		=> this.CreateChannelAsync(name, ChannelType.Voice, parent, Optional.None, bitrate, userLimit, overwrites, null, Optional.None, qualityMode, null, reason);
 
 	/// <summary>
 	/// Creates a new channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="type">Type of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="topic">Topic of the channel.</param>
 	/// <param name="bitrate">Bitrate of the channel. Applies to voice only.</param>
 	/// <param name="userLimit">Maximum number of users in the channel. Applies to voice only.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="nsfw">Whether the channel is to be flagged as not safe for work. Applies to text only.</param>
 	/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 	/// <param name="qualityMode">Video quality mode of the channel. Applies to voice only.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, ThreadAutoArchiveDuration? defaultAutoArchiveDuration = null, string reason = null) =>
 		// technically you can create news/store channels but not always
 		type != ChannelType.Text && type != ChannelType.Voice && type != ChannelType.Category && type != ChannelType.News && type != ChannelType.Store && type != ChannelType.Stage
 			? throw new ArgumentException("Channel type must be text, voice, stage, or category.", nameof(type))
 			: type == ChannelType.Category && parent != null
 				? throw new ArgumentException("Cannot specify parent of a channel category.", nameof(parent))
 				: this.Discord.ApiClient.CreateGuildChannelAsync(this.Id, name, type, parent?.Id, topic, bitrate, userLimit, overwrites, nsfw, perUserRateLimit, qualityMode, defaultAutoArchiveDuration, reason);
 
 	/// <summary>
 	/// Gets active threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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<DiscordThreadResult> GetActiveThreadsAsync()
 		=> this.Discord.ApiClient.GetActiveThreadsAsync(this.Id);
 
 	/// <summary>
 	/// <para>Deletes all channels in this guild.</para>
 	/// <para>Note that this is irreversible. Use carefully!</para>
 	/// </summary>
 	/// <returns></returns>
 	public Task DeleteAllChannelsAsync()
 	{
 		var tasks = this.Channels.Values.Select(xc => xc.DeleteAsync());
 		return Task.WhenAll(tasks);
 	}
 
 	/// <summary>
 	/// Estimates the number of users to be pruned.
 	/// </summary>
 	/// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
 	/// <param name="includedRoles">The roles to be included in the prune.</param>
 	/// <returns>Number of users that will be pruned.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<int> GetPruneCountAsync(int days = 7, IEnumerable<DiscordRole> includedRoles = null)
 	{
 		if (includedRoles != null)
 		{
 			includedRoles = includedRoles.Where(r => r != null);
 			var rawRoleIds = includedRoles
 				.Where(x => this.RolesInternal.ContainsKey(x.Id))
 				.Select(x => x.Id);
 
 			return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, rawRoleIds);
 		}
 
 		return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, null);
 	}
 
 	/// <summary>
 	/// Prunes inactive users from this guild.
 	/// </summary>
 	/// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
 	/// <param name="computePruneCount">Whether to return the prune count after this method completes. This is discouraged for larger guilds.</param>
 	/// <param name="includedRoles">The roles to be included in the prune.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>Number of users pruned.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<int?> PruneAsync(int days = 7, bool computePruneCount = true, IEnumerable<DiscordRole> includedRoles = null, string reason = null)
 	{
 		if (includedRoles != null)
 		{
 			includedRoles = includedRoles.Where(r => r != null);
 			var rawRoleIds = includedRoles
 				.Where(x => this.RolesInternal.ContainsKey(x.Id))
 				.Select(x => x.Id);
 
 			return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, rawRoleIds, reason);
 		}
 
 		return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, null, reason);
 	}
 
 	/// <summary>
 	/// Gets integrations attached to this guild.
 	/// </summary>
 	/// <returns>Collection of integrations attached to this guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordIntegration>> GetIntegrationsAsync()
 		=> this.Discord.ApiClient.GetGuildIntegrationsAsync(this.Id);
 
 	/// <summary>
 	/// Attaches an integration from current user to this guild.
 	/// </summary>
 	/// <param name="integration">Integration to attach.</param>
 	/// <returns>The integration after being attached to the guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordIntegration> AttachUserIntegrationAsync(DiscordIntegration integration)
 		=> this.Discord.ApiClient.CreateGuildIntegrationAsync(this.Id, integration.Type, integration.Id);
 
 	/// <summary>
 	/// Modifies an integration in this guild.
 	/// </summary>
 	/// <param name="integration">Integration to modify.</param>
 	/// <param name="expireBehaviour">Number of days after which the integration expires.</param>
 	/// <param name="expireGracePeriod">Length of grace period which allows for renewing the integration.</param>
 	/// <param name="enableEmoticons">Whether emotes should be synced from this integration.</param>
 	/// <returns>The modified integration.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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<DiscordIntegration> ModifyIntegrationAsync(DiscordIntegration integration, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 		=> this.Discord.ApiClient.ModifyGuildIntegrationAsync(this.Id, integration.Id, expireBehaviour, expireGracePeriod, enableEmoticons);
 
 	/// <summary>
 	/// Removes an integration from this guild.
 	/// </summary>
 	/// <param name="integration">Integration to remove.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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 DeleteIntegrationAsync(DiscordIntegration integration)
 		=> this.Discord.ApiClient.DeleteGuildIntegrationAsync(this.Id, integration);
 
 	/// <summary>
 	/// Forces re-synchronization of an integration for this guild.
 	/// </summary>
 	/// <param name="integration">Integration to synchronize.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the guild 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 SyncIntegrationAsync(DiscordIntegration integration)
 		=> this.Discord.ApiClient.SyncGuildIntegrationAsync(this.Id, integration.Id);
 
 	/// <summary>
 	/// Gets the voice regions for this guild.
 	/// </summary>
 	/// <returns>Voice regions available for this guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 	{
 		var vrs = await this.Discord.ApiClient.GetGuildVoiceRegionsAsync(this.Id).ConfigureAwait(false);
 		foreach (var xvr in vrs)
 			this.Discord.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 
 		return vrs;
 	}
 
 	/// <summary>
 	/// Gets an invite from this guild from an invite code.
 	/// </summary>
 	/// <param name="code">The invite code</param>
 	/// <returns>An invite, or null if not in cache.</returns>
 	public DiscordInvite GetInvite(string code)
 		=> this.Invites.TryGetValue(code, out var invite) ? invite : null;
 
 	/// <summary>
 	/// Gets all the invites created for all the channels in this guild.
 	/// </summary>
 	/// <returns>A collection of invites.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
 	{
 		var res = await this.Discord.ApiClient.GetGuildInvitesAsync(this.Id).ConfigureAwait(false);
 
 		var intents = this.Discord.Configuration.Intents;
 
 		if (!intents.HasIntent(DiscordIntents.GuildInvites))
 		{
 			foreach (var r in res)
 				this.Invites[r.Code] = r;
 		}
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets the vanity invite for this guild.
 	/// </summary>
 	/// <returns>A partial vanity invite.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> GetVanityInviteAsync()
 		=> this.Discord.ApiClient.GetGuildVanityUrlAsync(this.Id);
 
 	/// <summary>
 	/// Gets all the webhooks created for all the channels in this guild.
 	/// </summary>
 	/// <returns>A collection of webhooks this guild has.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 		=> this.Discord.ApiClient.GetGuildWebhooksAsync(this.Id);
 
 	/// <summary>
 	/// Gets this guild's widget image.
 	/// </summary>
 	/// <param name="bannerType">The format of the widget.</param>
 	/// <returns>The URL of the widget image.</returns>
 	public string GetWidgetImage(WidgetType bannerType = WidgetType.Shield)
 	{
 		var param = bannerType switch
 		{
 			WidgetType.Banner1 => "banner1",
 			WidgetType.Banner2 => "banner2",
 			WidgetType.Banner3 => "banner3",
 			WidgetType.Banner4 => "banner4",
 			_ => "shield",
 		};
 		return $"{Endpoints.BASE_URI}{Endpoints.GUILDS}/{this.Id}{Endpoints.WIDGET_PNG}?style={param}";
 	}
 
 	/// <summary>
 	/// Gets a member of this guild by their user ID.
 	/// </summary>
 	/// <param name="userId">ID of the member to get.</param>
 	/// <returns>The requested member.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMember> GetMemberAsync(ulong userId, bool fetch = false)
 	{
 		if (!fetch && this.MembersInternal != null && this.MembersInternal.TryGetValue(userId, out var mbr))
 			return mbr;
 
 		mbr = await this.Discord.ApiClient.GetGuildMemberAsync(this.Id, userId).ConfigureAwait(false);
 
 		var intents = this.Discord.Configuration.Intents;
 
 		if (intents.HasIntent(DiscordIntents.GuildMembers))
 		{
 			if (this.MembersInternal != null)
 			{
 				this.MembersInternal[userId] = mbr;
 			}
 		}
 
 		return mbr;
 	}
 
 	/// <summary>
 	/// Retrieves a full list of members from Discord. This method will bypass cache.
 	/// </summary>
 	/// <returns>A collection of all members in this guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyCollection<DiscordMember>> GetAllMembersAsync()
 	{
 		var recmbr = new HashSet<DiscordMember>();
 
 		var recd = 1000;
 		var last = 0ul;
 		while (recd > 0)
 		{
 			var tms = await this.Discord.ApiClient.ListGuildMembersAsync(this.Id, 1000, last == 0 ? null : (ulong?)last).ConfigureAwait(false);
 			recd = tms.Count;
 
 			foreach (var xtm in tms)
 			{
 				var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
 				usr = this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discord = usr.Discord;
 					old.AvatarHash = usr.AvatarHash;
 
 					return old;
 				});
 
 				recmbr.Add(new DiscordMember(xtm) { Discord = this.Discord, GuildId = this.Id });
 			}
 
 			var tm = tms.LastOrDefault();
 			last = tm?.User.Id ?? 0;
 		}
 
 		return new ReadOnlySet<DiscordMember>(recmbr);
 	}
 
 	/// <summary>
 	/// Requests that Discord send a list of guild members based on the specified arguments. This method will fire the <see cref="DiscordClient.GuildMembersChunked"/> event.
 	/// <para>If no arguments aside from <paramref name="presences"/> and <paramref name="nonce"/> are specified, this will request all guild members.</para>
 	/// </summary>
 	/// <param name="query">Filters the returned members based on what the username starts with. Either this or <paramref name="userIds"/> must not be null.
 	/// The <paramref name="limit"/> must also be greater than 0 if this is specified.</param>
 	/// <param name="limit">Total number of members to request. This must be greater than 0 if <paramref name="query"/> is specified.</param>
 	/// <param name="presences">Whether to include the <see cref="DisCatSharp.EventArgs.GuildMembersChunkEventArgs.Presences"/> associated with the fetched members.</param>
 	/// <param name="userIds">Whether to limit the request to the specified user ids. Either this or <paramref name="query"/> must not be null.</param>
 	/// <param name="nonce">The unique string to identify the response.</param>
 	public async Task RequestMembersAsync(string query = "", int limit = 0, bool? presences = null, IEnumerable<ulong> userIds = null, string nonce = null)
 	{
 		if (this.Discord is not DiscordClient client)
 			throw new InvalidOperationException("This operation is only valid for regular Discord clients.");
 
 		if (query == null && userIds == null)
 			throw new ArgumentException("The query and user IDs cannot both be null.");
 
 		if (query != null && userIds != null)
 			query = null;
 
 		var grgm = new GatewayRequestGuildMembers(this)
 		{
 			Query = query,
 			Limit = limit >= 0 ? limit : 0,
 			Presences = presences,
 			UserIds = userIds,
 			Nonce = nonce
 		};
 
 		var payload = new GatewayPayload
 		{
 			OpCode = GatewayOpCode.RequestGuildMembers,
 			Data = grgm
 		};
 
 		var payloadStr = JsonConvert.SerializeObject(payload, Formatting.None);
 		await client.WsSendAsync(payloadStr).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets all the channels this guild has.
 	/// </summary>
 	/// <returns>A collection of this guild's channels.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordChannel>> GetChannelsAsync()
 		=> this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
 	/// <summary>
 	/// Creates a new role in this guild.
 	/// </summary>
 	/// <param name="name">Name of the role.</param>
 	/// <param name="permissions">Permissions for the role.</param>
 	/// <param name="color">Color for the role.</param>
 	/// <param name="hoist">Whether the role is to be hoisted.</param>
 	/// <param name="mentionable">Whether the role is to be mentionable.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created role.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordRole> CreateRoleAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
 		=> this.Discord.ApiClient.CreateGuildRoleAsync(this.Id, name, permissions, color?.Value, hoist, mentionable, reason);
 
 	/// <summary>
 	/// Gets a role from this guild by its ID.
 	/// </summary>
 	/// <param name="id">ID of the role to get.</param>
 	/// <returns>Requested role.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordRole GetRole(ulong id)
 		=> this.RolesInternal.TryGetValue(id, out var role) ? role : null;
 
 	/// <summary>
 	/// Gets a channel from this guild by its ID.
 	/// </summary>
 	/// <param name="id">ID of the channel to get.</param>
 	/// <returns>Requested channel.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordChannel GetChannel(ulong id)
 		=> this.ChannelsInternal != null && this.ChannelsInternal.TryGetValue(id, out var channel) ? channel : null;
 
 	/// <summary>
 	/// Gets a thread from this guild by its ID.
 	/// </summary>
 	/// <param name="id">ID of the thread to get.</param>
 	/// <returns>Requested thread.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordThreadChannel GetThread(ulong id)
 		=> this.ThreadsInternal != null && this.ThreadsInternal.TryGetValue(id, out var thread) ? thread : null;
 
 	/// <summary>
 	/// Gets all of this guild's custom emojis.
 	/// </summary>
 	/// <returns>All of this guild's custom emojis.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordGuildEmoji>> GetEmojisAsync()
 		=> this.Discord.ApiClient.GetGuildEmojisAsync(this.Id);
 
 	/// <summary>
 	/// Gets this guild's specified custom emoji.
 	/// </summary>
 	/// <param name="id">ID of the emoji to get.</param>
 	/// <returns>The requested custom emoji.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildEmoji> GetEmojiAsync(ulong id)
 		=> this.Discord.ApiClient.GetGuildEmojiAsync(this.Id, id);
 
 	/// <summary>
 	/// Creates a new custom emoji for this guild.
 	/// </summary>
 	/// <param name="name">Name of the new emoji.</param>
 	/// <param name="image">Image to use as the emoji.</param>
 	/// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
 	/// <param name="reason">Reason for audit log.</param>
 	/// <returns>The newly-created emoji.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildEmoji> CreateEmojiAsync(string name, Stream image, IEnumerable<DiscordRole> roles = null, string reason = null)
 	{
 		if (string.IsNullOrWhiteSpace(name))
 			throw new ArgumentNullException(nameof(name));
 
 		name = name.Trim();
 		if (name.Length < 2 || name.Length > 50)
 			throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.");
 
 		if (image == null)
 			throw new ArgumentNullException(nameof(image));
 
 		var image64 = ImageTool.Base64FromStream(image);
 
 		return this.Discord.ApiClient.CreateGuildEmojiAsync(this.Id, name, image64, roles?.Select(xr => xr.Id), reason);
 	}
 
 	/// <summary>
 	/// Modifies a this guild's custom emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to modify.</param>
 	/// <param name="name">New name for the emoji.</param>
 	/// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
 	/// <param name="reason">Reason for audit log.</param>
 	/// <returns>The modified emoji.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildEmoji> ModifyEmojiAsync(DiscordGuildEmoji emoji, string name, IEnumerable<DiscordRole> roles = null, string reason = null)
 	{
 		if (emoji == null)
 			throw new ArgumentNullException(nameof(emoji));
 
 		if (emoji.Guild.Id != this.Id)
 			throw new ArgumentException("This emoji does not belong to this guild.");
 
 		if (string.IsNullOrWhiteSpace(name))
 			throw new ArgumentNullException(nameof(name));
 
 		name = name.Trim();
 		return name.Length < 2 || name.Length > 50
 			? throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.")
 			: this.Discord.ApiClient.ModifyGuildEmojiAsync(this.Id, emoji.Id, name, roles?.Select(xr => xr.Id), reason);
 	}
 
 	/// <summary>
 	/// Deletes this guild's custom emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to delete.</param>
 	/// <param name="reason">Reason for audit log.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteEmojiAsync(DiscordGuildEmoji emoji, string reason = null) =>
 		emoji == null
 			? throw new ArgumentNullException(nameof(emoji))
 			: emoji.Guild.Id != this.Id
 				? throw new ArgumentException("This emoji does not belong to this guild.")
 				: this.Discord.ApiClient.DeleteGuildEmojiAsync(this.Id, emoji.Id, reason);
 
 	/// <summary>
 	/// Gets all of this guild's custom stickers.
 	/// </summary>
 	/// <returns>All of this guild's custom stickers.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordSticker>> GetStickersAsync()
 	{
 		var stickers = await this.Discord.ApiClient.GetGuildStickersAsync(this.Id);
 
 		foreach (var xstr in stickers)
 		{
 			this.StickersInternal.AddOrUpdate(xstr.Id, xstr, (id, old) =>
 			{
 				old.Name = xstr.Name;
 				old.Description = xstr.Description;
 				old.InternalTags = xstr.InternalTags;
 				return old;
 			});
 		}
 
 		return stickers;
 	}
 
 	/// <summary>
 	/// Gets a sticker
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task<DiscordSticker> GetStickerAsync(ulong stickerId)
 		=> this.Discord.ApiClient.GetGuildStickerAsync(this.Id, stickerId);
 
 	/// <summary>
 	/// Creates a sticker
 	/// </summary>
 	/// <param name="name">The name of the sticker.</param>
 	/// <param name="description">The optional description of the sticker.</param>
 	/// <param name="emoji">The emoji to associate the sticker with.</param>
 	/// <param name="format">The file format the sticker is written in.</param>
 	/// <param name="file">The sticker.</param>
 	/// <param name="reason">Audit log reason</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordSticker> CreateStickerAsync(string name, string description, DiscordEmoji emoji, Stream file, StickerFormat format, string reason = null)
 	{
 		var fileExt = format switch
 		{
 			StickerFormat.Png => "png",
 			StickerFormat.Apng => "png",
 			StickerFormat.Lottie => "json",
 			_ => throw new InvalidOperationException("This format is not supported.")
 		};
 
 		var contentType = format switch
 		{
 			StickerFormat.Png => "image/png",
 			StickerFormat.Apng => "image/png",
 			StickerFormat.Lottie => "application/json",
 			_ => throw new InvalidOperationException("This format is not supported.")
 		};
 
 		return emoji.Id is not 0
 			? throw new InvalidOperationException("Only unicode emoji can be used for stickers.")
 			: name.Length < 2 || name.Length > 30
 			? throw new ArgumentOutOfRangeException(nameof(name), "Sticker name needs to be between 2 and 30 characters long.")
 			: description.Length < 1 || description.Length > 100
 			? throw new ArgumentOutOfRangeException(nameof(description), "Sticker description needs to be between 1 and 100 characters long.")
 			: this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new DiscordMessageFile("sticker", file, null, fileExt, contentType), reason);
 	}
 
 	/// <summary>
 	/// Modifies a sticker
 	/// </summary>
 	/// <param name="sticker">The id of the sticker to modify</param>
 	/// <param name="name">The name of the sticker</param>
 	/// <param name="description">The description of the sticker</param>
 	/// <param name="emoji">The emoji to associate with this sticker.</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <returns>A sticker object</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public async Task<DiscordSticker> ModifyStickerAsync(ulong sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
 	{
 		if (!this.StickersInternal.TryGetValue(sticker, out var stickerobj) || stickerobj.Guild.Id != this.Id)
 			throw new ArgumentException("This sticker does not belong to this guild.");
 		if (name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30))
 			throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.");
 		if (description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100))
 			throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.");
 		if (emoji.HasValue && emoji.Value.Id > 0)
 			throw new ArgumentException("Only unicode emojis can be used with stickers.");
 
 		string uemoji = null;
 		if (emoji.HasValue)
 			uemoji = emoji.Value.GetDiscordName().Replace(":", "");
 
 		var usticker = await this.Discord.ApiClient.ModifyGuildStickerAsync(this.Id, sticker, name, description, uemoji, reason).ConfigureAwait(false);
 
 
 		if (this.StickersInternal.TryGetValue(usticker.Id, out var old))
 			this.StickersInternal.TryUpdate(usticker.Id, usticker, old);
 
 		return usticker;
 	}
 
 	/// <summary>
 	/// Modifies a sticker
 	/// </summary>
 	/// <param name="sticker">The sticker to modify</param>
 	/// <param name="name">The name of the sticker</param>
 	/// <param name="description">The description of the sticker</param>
 	/// <param name="emoji">The emoji to associate with this sticker.</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <returns>A sticker object</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task<DiscordSticker> ModifyStickerAsync(DiscordSticker sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
 		=> this.ModifyStickerAsync(sticker.Id, name, description, emoji, reason);
 
 	/// <summary>
 	/// Deletes a sticker
 	/// </summary>
 	/// <param name="sticker">Id of sticker to delete</param>
 	/// <param name="reason">Audit log reason</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task DeleteStickerAsync(ulong sticker, string reason = null) =>
 		!this.StickersInternal.TryGetValue(sticker, out var stickerobj)
 			? throw new ArgumentNullException(nameof(sticker))
 			: stickerobj.Guild.Id != this.Id
 				? throw new ArgumentException("This sticker does not belong to this guild.")
 				: this.Discord.ApiClient.DeleteGuildStickerAsync(this.Id, sticker, reason);
 
 	/// <summary>
 	/// Deletes a sticker
 	/// </summary>
 	/// <param name="sticker">Sticker to delete</param>
 	/// <param name="reason">Audit log reason</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task DeleteStickerAsync(DiscordSticker sticker, string reason = null)
 		=> this.DeleteStickerAsync(sticker.Id, reason);
 
 	/// <summary>
 	/// <para>Gets the default channel for this guild.</para>
 	/// <para>Default channel is the first channel current member can see.</para>
 	/// </summary>
 	/// <returns>This member's default guild.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordChannel GetDefaultChannel() =>
 		this.ChannelsInternal?.Values.Where(xc => xc.Type == ChannelType.Text)
 			.OrderBy(xc => xc.Position)
 			.FirstOrDefault(xc => (xc.PermissionsFor(this.CurrentMember) & DisCatSharp.Permissions.AccessChannels) == DisCatSharp.Permissions.AccessChannels);
 
 	/// <summary>
 	/// Gets the guild's widget
 	/// </summary>
 	/// <returns>The guild's widget</returns>
 	public Task<DiscordWidget> GetWidgetAsync()
 		=> this.Discord.ApiClient.GetGuildWidgetAsync(this.Id);
 
 	/// <summary>
 	/// Gets the guild's widget settings
 	/// </summary>
 	/// <returns>The guild's widget settings</returns>
 	public Task<DiscordWidgetSettings> GetWidgetSettingsAsync()
 		=> this.Discord.ApiClient.GetGuildWidgetSettingsAsync(this.Id);
 
 	/// <summary>
 	/// Modifies the guild's widget settings
 	/// </summary>
 	/// <param name="isEnabled">If the widget is enabled or not</param>
 	/// <param name="channel">Widget channel</param>
 	/// <param name="reason">Reason the widget settings were modified</param>
 	/// <returns>The newly modified widget settings</returns>
 	public Task<DiscordWidgetSettings> ModifyWidgetSettingsAsync(bool? isEnabled = null, DiscordChannel channel = null, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildWidgetSettingsAsync(this.Id, isEnabled, channel?.Id, reason);
 
 	/// <summary>
 	/// Gets all of this guild's templates.
 	/// </summary>
 	/// <returns>All of the guild's templates.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordGuildTemplate>> GetTemplatesAsync()
 		=> this.Discord.ApiClient.GetGuildTemplatesAsync(this.Id);
 
 	/// <summary>
 	/// Creates a guild template.
 	/// </summary>
 	/// <param name="name">Name of the template.</param>
 	/// <param name="description">Description of the template.</param>
 	/// <returns>The template created.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
+	/// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> CreateTemplateAsync(string name, string description = null)
 		=> this.Discord.ApiClient.CreateGuildTemplateAsync(this.Id, name, description);
 
 	/// <summary>
 	/// Syncs the template to the current guild's state.
 	/// </summary>
 	/// <param name="code">The code of the template to sync.</param>
 	/// <returns>The template synced.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
+	/// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> SyncTemplateAsync(string code)
 		=> this.Discord.ApiClient.SyncGuildTemplateAsync(this.Id, code);
 
 	/// <summary>
 	/// Modifies the template's metadata.
 	/// </summary>
 	/// <param name="code">The template's code.</param>
 	/// <param name="name">Name of the template.</param>
 	/// <param name="description">Description of the template.</param>
 	/// <returns>The template modified.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
+	/// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> ModifyTemplateAsync(string code, string name = null, string description = null)
 		=> this.Discord.ApiClient.ModifyGuildTemplateAsync(this.Id, code, name, description);
 
 	/// <summary>
 	/// Deletes the template.
 	/// </summary>
 	/// <param name="code">The code of the template to delete.</param>
 	/// <returns>The deleted template.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
+	/// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> DeleteTemplateAsync(string code)
 		=> this.Discord.ApiClient.DeleteGuildTemplateAsync(this.Id, code);
 
 	/// <summary>
 	/// Gets this guild's membership screening form.
 	/// </summary>
 	/// <returns>This guild's membership screening form.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildMembershipScreening> GetMembershipScreeningFormAsync()
 		=> this.Discord.ApiClient.GetGuildMembershipScreeningFormAsync(this.Id);
 
 	/// <summary>
 	/// Modifies this guild's membership screening form.
 	/// </summary>
 	/// <param name="action">Action to perform</param>
 	/// <returns>The modified screening form.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuildMembershipScreening> ModifyMembershipScreeningFormAsync(Action<MembershipScreeningEditModel> action)
 	{
 		var mdl = new MembershipScreeningEditModel();
 		action(mdl);
 		return await this.Discord.ApiClient.ModifyGuildMembershipScreeningFormAsync(this.Id, mdl.Enabled, mdl.Fields, mdl.Description);
 	}
 
 	/// <summary>
 	/// Gets all the application commands in this guild.
 	/// </summary>
 	/// <returns>A list of application commands in this guild.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetApplicationCommandsAsync() =>
 		this.Discord.ApiClient.GetGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id);
 
 	/// <summary>
 	/// Overwrites the existing application commands in this guild. New commands are automatically created and missing commands are automatically delete
 	/// </summary>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of guild commands</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 		this.Discord.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id, commands);
 
 	/// <summary>
 	/// Creates or overwrites a application command in this guild.
 	/// </summary>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateApplicationCommandAsync(DiscordApplicationCommand command) =>
 		this.Discord.ApiClient.CreateGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, command);
 
 	/// <summary>
 	/// Edits a application command in this guild.
 	/// </summary>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edit command.</returns>
 	public async Task<DiscordApplicationCommand> EditApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		return await this.Discord.ApiClient.EditGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets this guild's welcome screen.
 	/// </summary>
 	/// <returns>This guild's welcome screen object.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildWelcomeScreen> GetWelcomeScreenAsync() =>
 		this.Discord.ApiClient.GetGuildWelcomeScreenAsync(this.Id);
 
 	/// <summary>
 	/// Modifies this guild's welcome screen.
 	/// </summary>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The modified welcome screen.</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuildWelcomeScreen> ModifyWelcomeScreenAsync(Action<WelcomeScreenEditModel> action)
 	{
 		var mdl = new WelcomeScreenEditModel();
 		action(mdl);
 		return await this.Discord.ApiClient.ModifyGuildWelcomeScreenAsync(this.Id, mdl.Enabled, mdl.WelcomeChannels, mdl.Description).ConfigureAwait(false);
 	}
 	#endregion
 
 	/// <summary>
 	/// Returns a string representation of this guild.
 	/// </summary>
 	/// <returns>String representation of this guild.</returns>
 	public override string ToString()
 		=> $"Guild {this.Id}; {this.Name}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordGuild"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordGuild"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordGuild);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordGuild"/> is equal to another <see cref="DiscordGuild"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordGuild"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordGuild"/> is equal to this <see cref="DiscordGuild"/>.</returns>
 	public bool Equals(DiscordGuild e)
 		=> e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordGuild"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordGuild"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordGuild"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First guild to compare.</param>
 	/// <param name="e2">Second guild to compare.</param>
 	/// <returns>Whether the two guilds are equal.</returns>
 	public static bool operator ==(DiscordGuild e1, DiscordGuild e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordGuild"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First guild to compare.</param>
 	/// <param name="e2">Second guild to compare.</param>
 	/// <returns>Whether the two guilds are not equal.</returns>
 	public static bool operator !=(DiscordGuild e1, DiscordGuild e2)
 		=> !(e1 == e2);
 
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuildEmoji.cs b/DisCatSharp/Entities/Guild/DiscordGuildEmoji.cs
index cde206710..1e50822e3 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuildEmoji.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuildEmoji.cs
@@ -1,77 +1,77 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a guild emoji.
 /// </summary>
 public sealed class DiscordGuildEmoji : DiscordEmoji
 {
 	/// <summary>
 	/// Gets the user that created this emoji.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild to which this emoji belongs.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordGuildEmoji"/> class.
 	/// </summary>
 	internal DiscordGuildEmoji()
 	{ }
 
 	/// <summary>
 	/// Modifies this emoji.
 	/// </summary>
 	/// <param name="name">New name for this emoji.</param>
 	/// <param name="roles">Roles for which this emoji will be available. This works only if your application is whitelisted as integration.</param>
 	/// <param name="reason">Reason for audit log.</param>
 	/// <returns>The modified emoji.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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<DiscordGuildEmoji> ModifyAsync(string name, IEnumerable<DiscordRole> roles = null, string reason = null)
 		=> this.Guild.ModifyEmojiAsync(this, name, roles, reason);
 
 	/// <summary>
 	/// Deletes this emoji.
 	/// </summary>
 	/// <param name="reason">Reason for audit log.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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.Guild.DeleteEmojiAsync(this, reason);
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordMember.cs b/DisCatSharp/Entities/Guild/DiscordMember.cs
index 0d20571d1..8166077d8 100644
--- a/DisCatSharp/Entities/Guild/DiscordMember.cs
+++ b/DisCatSharp/Entities/Guild/DiscordMember.cs
@@ -1,795 +1,795 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord guild member.
 /// </summary>
 public class DiscordMember : DiscordUser, IEquatable<DiscordMember>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	internal DiscordMember()
 	{
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	/// <param name="user">The user.</param>
 	internal DiscordMember(DiscordUser user)
 	{
 		this.Discord = user.Discord;
 
 		this.Id = user.Id;
 
 		this.RoleIdsInternal = new List<ulong>();
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	/// <param name="mbr">The mbr.</param>
 	internal DiscordMember(TransportMember mbr)
 	{
 		this.Id = mbr.User.Id;
 		this.IsDeafened = mbr.IsDeafened;
 		this.IsMuted = mbr.IsMuted;
 		this.JoinedAt = mbr.JoinedAt;
 		this.Nickname = mbr.Nickname;
 		this.PremiumSince = mbr.PremiumSince;
 		this.IsPending = mbr.IsPending;
 		this.GuildAvatarHash = mbr.GuildAvatarHash;
 		this.GuildBannerHash = mbr.GuildBannerHash;
 		this.GuildBio = mbr.GuildBio;
 		this.GuildPronouns = mbr.GuildPronouns;
 		this.CommunicationDisabledUntil = mbr.CommunicationDisabledUntil;
 		this.AvatarHashInternal = mbr.AvatarHash;
 		this.RoleIdsInternal = mbr.Roles ?? new List<ulong>();
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 		this.MemberFlags = mbr.MemberFlags;
 	}
 
 	/// <summary>
 	/// Gets the members avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string GuildAvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the members avatar URL.
 	/// </summary>
 	[JsonIgnore]
 	public string GuildAvatarUrl
 		=> string.IsNullOrWhiteSpace(this.GuildAvatarHash) ? this.User.AvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this.GuildId.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.AVATARS}/{this.GuildAvatarHash}.{(this.GuildAvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the members banner hash.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string GuildBannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the members banner URL.
 	/// </summary>
 	[JsonIgnore]
 	public string GuildBannerUrl
 		=> string.IsNullOrWhiteSpace(this.GuildBannerHash) ? this.User.BannerUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this.GuildId.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.GuildBannerHash}.{(this.GuildBannerHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// The color of this member's banner. Mutually exclusive with <see cref="GuildBannerHash"/>.
 	/// </summary>
 	[JsonIgnore]
 	public override DiscordColor? BannerColor => this.User.BannerColor;
 
 	/// <summary>
 	/// Gets this member's nickname.
 	/// </summary>
 	[JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nickname { get; internal set; }
 
 	/// <summary>
 	/// Gets the members guild bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildBio { get; internal set; }
 
 	/// <summary>
 	/// Gets the members's pronouns.
 	/// </summary>
 	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildPronouns { get; internal set; }
 
 	/// <summary>
 	/// Gets the members flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MemberFlags MemberFlags { get; internal set; }
 
 	[JsonIgnore]
 	internal string AvatarHashInternal;
 
 	/// <summary>
 	/// Gets this member's display name.
 	/// </summary>
 	[JsonIgnore]
 	public string DisplayName
 		=> this.Nickname ?? this.Username;
 
 	/// <summary>
 	/// List of role ids
 	/// </summary>
 	[JsonIgnore]
 	internal IReadOnlyList<ulong> RoleIds
 		=> this._roleIdsLazy.Value;
 
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<ulong> RoleIdsInternal;
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<ulong>> _roleIdsLazy;
 
 	/// <summary>
 	/// Gets the list of roles associated with this member.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<DiscordRole> Roles
 		=> this.RoleIds.Select(id => this.Guild.GetRole(id)).Where(x => x != null);
 
 	/// <summary>
 	/// Gets the color associated with this user's top color-giving role, otherwise 0 (no color).
 	/// </summary>
 	[JsonIgnore]
 	public DiscordColor Color
 	{
 		get
 		{
 			var role = this.Roles.OrderByDescending(xr => xr.Position).FirstOrDefault(xr => xr.Color.Value != 0);
 			return role != null ? role.Color : new DiscordColor();
 		}
 	}
 
 	/// <summary>
 	/// Date the user joined the guild
 	/// </summary>
 	[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset JoinedAt { get; internal set; }
 
 	/// <summary>
 	/// Date the user started boosting this server
 	/// </summary>
 	[JsonProperty("premium_since", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset? PremiumSince { get; internal set; }
 
 	/// <summary>
 	/// Date until the can communicate again.
 	/// </summary>
 	[JsonProperty("communication_disabled_until", NullValueHandling = NullValueHandling.Include)]
 	public DateTime? CommunicationDisabledUntil { get; internal set; }
 
 	/// <summary>
 	/// If the user is deafened
 	/// </summary>
 	[JsonProperty("is_deafened", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsDeafened { get; internal set; }
 
 	/// <summary>
 	/// If the user is muted
 	/// </summary>
 	[JsonProperty("is_muted", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsMuted { get; internal set; }
 
 	/// <summary>
 	/// Whether the user has not passed the guild's Membership Screening requirements yet.
 	/// </summary>
 	[JsonProperty("pending", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsPending { get; internal set; }
 
 	/// <summary>
 	/// Gets this member's voice state.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceState VoiceState
 		=> this.Discord.Guilds[this.GuildId].VoiceStates.TryGetValue(this.Id, out var voiceState) ? voiceState : null;
 
 	[JsonIgnore]
 	internal ulong GuildId = 0;
 
 	/// <summary>
 	/// Gets the guild of which this member is a part of.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.Discord.Guilds[this.GuildId];
 
 	/// <summary>
 	/// Gets whether this member is the Guild owner.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsOwner
 		=> this.Id == this.Guild.OwnerId;
 
 	/// <summary>
 	/// Gets the member's position in the role hierarchy, which is the member's highest role's position. Returns <see cref="int.MaxValue"/> for the guild's owner.
 	/// </summary>
 	[JsonIgnore]
 	public int Hierarchy
 		=> this.IsOwner ? int.MaxValue : this.RoleIds.Count == 0 ? 0 : this.Roles.Max(x => x.Position);
 
 	/// <summary>
 	/// Gets the permissions for the current member.
 	/// </summary>
 	[JsonIgnore]
 	public Permissions Permissions => this.GetPermissions();
 
 	#region Overridden user properties
 
 	/// <summary>
 	/// Gets the user.
 	/// </summary>
 	[JsonIgnore]
 	internal DiscordUser User
 		=> this.Discord.UserCache[this.Id];
 
 	/// <summary>
 	/// Gets this member's username.
 	/// </summary>
 	[JsonIgnore]
 	public override string Username
 	{
 		get => this.User.Username;
 		internal set => this.User.Username = value;
 	}
 
 	/// <summary>
 	/// Gets the member's 4-digit discriminator.
 	/// </summary>
 	[JsonIgnore]
 	public override string Discriminator
 	{
 		get => this.User.Discriminator;
 		internal set => this.User.Discriminator = value;
 	}
 
 	/// <summary>
 	/// Gets the member's avatar hash.
 	/// </summary>
 	[JsonIgnore]
 	public override string AvatarHash
 	{
 		get => this.User.AvatarHash;
 		internal set => this.User.AvatarHash = value;
 	}
 
 	/// <summary>
 	/// Gets the member's banner hash.
 	/// </summary>
 	[JsonIgnore]
 	public override string BannerHash
 	{
 		get => this.User.BannerHash;
 		internal set => this.User.BannerHash = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member is a bot.
 	/// </summary>
 	[JsonIgnore]
 	public override bool IsBot
 	{
 		get => this.User.IsBot;
 		internal set => this.User.IsBot = value;
 	}
 
 	/// <summary>
 	/// Gets the member's email address.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonIgnore]
 	public override string Email
 	{
 		get => this.User.Email;
 		internal set => this.User.Email = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member has multi-factor authentication enabled.
 	/// </summary>
 	[JsonIgnore]
 	public override bool? MfaEnabled
 	{
 		get => this.User.MfaEnabled;
 		internal set => this.User.MfaEnabled = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member is verified.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonIgnore]
 	public override bool? Verified
 	{
 		get => this.User.Verified;
 		internal set => this.User.Verified = value;
 	}
 
 	/// <summary>
 	/// Gets the member's chosen language
 	/// </summary>
 	[JsonIgnore]
 	public override string Locale
 	{
 		get => this.User.Locale;
 		internal set => this.User.Locale = value;
 	}
 
 	/// <summary>
 	/// Gets the user's flags.
 	/// </summary>
 	[JsonIgnore]
 	public override UserFlags? OAuthFlags
 	{
 		get => this.User.OAuthFlags;
 		internal set => this.User.OAuthFlags = value;
 	}
 
 	/// <summary>
 	/// Gets the member's flags for OAuth.
 	/// </summary>
 	[JsonIgnore]
 	public override UserFlags? Flags
 	{
 		get => this.User.Flags;
 		internal set => this.User.Flags = value;
 	}
 
 	#endregion
 
 	/// <summary>
 	/// Creates a direct message channel to this member.
 	/// </summary>
 	/// <returns>Direct message channel to this member.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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<DiscordDmChannel> CreateDmChannelAsync()
 		=> this.Discord.ApiClient.CreateDmAsync(this.Id);
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> SendMessageAsync(string content)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(content).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> SendMessageAsync(DiscordEmbed embed)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(embed).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> SendMessageAsync(string content, DiscordEmbed embed)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(content, embed).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="message">Builder to with the message.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> SendMessageAsync(DiscordMessageBuilder message)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(message).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sets this member's voice mute status.
 	/// </summary>
 	/// <param name="mute">Whether the member is to be muted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 SetMuteAsync(bool mute, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, mute, default, default, reason);
 
 	/// <summary>
 	/// Sets this member's voice deaf status.
 	/// </summary>
 	/// <param name="deaf">Whether the member is to be deafened.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.DeafenMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.DeafenMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 SetDeafAsync(bool deaf, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, default, deaf, default, reason);
 
 	/// <summary>
 	/// Modifies this member.
 	/// </summary>
 	/// <param name="action">Action to perform on this member.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageNicknames"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageNicknames"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 ModifyAsync(Action<MemberEditModel> action)
 	{
 		var mdl = new MemberEditModel();
 		action(mdl);
 
 		if (mdl.VoiceChannel.HasValue && mdl.VoiceChannel.Value != null && mdl.VoiceChannel.Value.Type != ChannelType.Voice && mdl.VoiceChannel.Value.Type != ChannelType.Stage)
 			throw new ArgumentException("Given channel is not a voice or stage channel.", nameof(action));
 
 		if (mdl.Nickname.HasValue && this.Discord.CurrentUser.Id == this.Id)
 		{
 			await this.Discord.ApiClient.ModifyCurrentMemberNicknameAsync(this.Guild.Id, mdl.Nickname.Value,
 				mdl.AuditLogReason).ConfigureAwait(false);
 
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, Optional.None,
 				mdl.Roles.Map(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
 				mdl.VoiceChannel.Map(e => e?.Id), mdl.AuditLogReason).ConfigureAwait(false);
 		}
 		else
 		{
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, mdl.Nickname,
 				mdl.Roles.Map(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
 				mdl.VoiceChannel.Map(e => e?.Id), mdl.AuditLogReason).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Disconnects the member from their current voice channel.
 	/// </summary>
 	public async Task DisconnectFromVoiceAsync() => await this.ModifyAsync(x => x.VoiceChannel = null);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 TimeoutAsync(DateTimeOffset until, string reason = null)
 		=> until.Subtract(DateTimeOffset.UtcNow).Days > 28 ? throw new ArgumentException("Timeout can not be longer than 28 days") : this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, until, reason);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The timespan to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 TimeoutAsync(TimeSpan until, string reason = null)
 		=> this.TimeoutAsync(DateTimeOffset.UtcNow + until, reason);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The datetime to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 TimeoutAsync(DateTime until, string reason = null)
 		=> this.TimeoutAsync(until.ToUniversalTime() - DateTime.UtcNow, reason);
 
 	/// <summary>
 	/// Removes the timeout from a member.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 RemoveTimeoutAsync(string reason = null) => this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, null, reason);
 
 	/// <summary>
 	/// Grants a role to the member.
 	/// </summary>
 	/// <param name="role">Role to grant.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 GrantRoleAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.AddGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Revokes a role from a member.
 	/// </summary>
 	/// <param name="role">Role to revoke.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 RevokeRoleAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Sets the member's roles to ones specified.
 	/// </summary>
 	/// <param name="roles">Roles to set.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 ReplaceRolesAsync(IEnumerable<DiscordRole> roles, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, default,
 			Optional.Some(roles.Select(xr => xr.Id)), default, default, default, reason);
 
 	/// <summary>
 	/// Bans this member from their guild.
 	/// </summary>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 BanAsync(int deleteMessageDays = 0, string reason = null)
 		=> this.Guild.BanMemberAsync(this, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Unbans this member from their guild.
 	/// </summary>
 	/// <exception cref = "Exceptions.UnauthorizedException" > Thrown when the client does not have the<see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 UnbanAsync(string reason = null) => this.Guild.UnbanMemberAsync(this, reason);
 
 	/// <summary>
 	/// Kicks this member from their guild.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns></returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 RemoveAsync(string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildMemberAsync(this.GuildId, this.Id, reason);
 
 	/// <summary>
 	/// Moves this member to the specified voice channel
 	/// </summary>
 	/// <param name="channel"></param>
 
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 PlaceInAsync(DiscordChannel channel)
 		=> channel.PlaceMemberAsync(this);
 
 	/// <summary>
 	/// Updates the member's suppress state in a stage channel.
 	/// </summary>
 	/// <param name="channel">The channel the member is currently in.</param>
 	/// <param name="suppress">Toggles the member's suppress state.</param>
-	/// <exception cref="System.ArgumentException">Thrown when the channel in not a voice channel.</exception>
+	/// <exception cref="ArgumentException">Thrown when the channel in not a voice channel.</exception>
 	public async Task UpdateVoiceStateAsync(DiscordChannel channel, bool? suppress)
 	{
 		if (channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, channel.Id, suppress).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Makes the user a speaker.
 	/// </summary>
-	/// <exception cref="System.ArgumentException">Thrown when the user is not inside an stage channel.</exception>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Thrown when the user is not inside an stage channel.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 MakeSpeakerAsync()
 	{
 		var vs = this.VoiceState;
 		if (vs == null || vs.Channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, false).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Moves the user to audience.
 	/// </summary>
-	/// <exception cref="System.ArgumentException">Thrown when the user is not inside an stage channel.</exception>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Thrown when the user is not inside an stage channel.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 MoveToAudienceAsync()
 	{
 		var vs = this.VoiceState;
 		if (vs == null || vs.Channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, true).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Calculates permissions in a given channel for this member.
 	/// </summary>
 	/// <param name="channel">Channel to calculate permissions for.</param>
 	/// <returns>Calculated permissions for this member in the channel.</returns>
 	public Permissions PermissionsIn(DiscordChannel channel)
 		=> channel.PermissionsFor(this);
 
 	/// <summary>
 	/// Get's the current member's roles based on the sum of the permissions of their given roles.
 	/// </summary>
 	private Permissions GetPermissions()
 	{
 		if (this.Guild.OwnerId == this.Id)
 			return PermissionMethods.FullPerms;
 
 		Permissions perms;
 
 		// assign @everyone permissions
 		var everyoneRole = this.Guild.EveryoneRole;
 		perms = everyoneRole.Permissions;
 
 		// assign permissions from member's roles (in order)
 		perms |= this.Roles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
 		// Administrator grants all permissions and cannot be overridden
 		return (perms & Permissions.Administrator) == Permissions.Administrator ? PermissionMethods.FullPerms : perms;
 	}
 
 	/// <summary>
 	/// Returns a string representation of this member.
 	/// </summary>
 	/// <returns>String representation of this member.</returns>
 	public override string ToString()
 		=> $"Member {this.Id}; {this.Username}#{this.Discriminator} ({this.DisplayName})";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMember"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordMember"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordMember);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMember"/> is equal to another <see cref="DiscordMember"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordMember"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordMember"/> is equal to this <see cref="DiscordMember"/>.</returns>
 	public bool Equals(DiscordMember e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.GuildId == e.GuildId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordMember"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordMember"/>.</returns>
 	public override int GetHashCode()
 	{
 		var hash = 13;
 
 		hash = (hash * 7) + this.Id.GetHashCode();
 		hash = (hash * 7) + this.GuildId.GetHashCode();
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMember"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First member to compare.</param>
 	/// <param name="e2">Second member to compare.</param>
 	/// <returns>Whether the two members are equal.</returns>
 	public static bool operator ==(DiscordMember e1, DiscordMember e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.GuildId == e2.GuildId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMember"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First member to compare.</param>
 	/// <param name="e2">Second member to compare.</param>
 	/// <returns>Whether the two members are not equal.</returns>
 	public static bool operator !=(DiscordMember e1, DiscordMember e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordRole.cs b/DisCatSharp/Entities/Guild/DiscordRole.cs
index 5bd61dc35..2ea000214 100644
--- a/DisCatSharp/Entities/Guild/DiscordRole.cs
+++ b/DisCatSharp/Entities/Guild/DiscordRole.cs
@@ -1,292 +1,292 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord role, to which users can be assigned.
 /// </summary>
 public class DiscordRole : SnowflakeObject, IEquatable<DiscordRole>
 {
 	/// <summary>
 	/// Gets the name of this role.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the color of this role.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordColor Color
 		=> new(this.ColorInternal);
 
 	[JsonProperty("color", NullValueHandling = NullValueHandling.Ignore)]
 	internal int ColorInternal;
 
 	/// <summary>
 	/// Gets whether this role is hoisted.
 	/// </summary>
 	[JsonProperty("hoist", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsHoisted { get; internal set; }
 
 	/// <summary>
 	/// Gets the position of this role in the role hierarchy.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; internal set; }
 
 	/// <summary>
 	/// Gets the permissions set for this role.
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Permissions { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this role is managed by an integration.
 	/// </summary>
 	[JsonProperty("managed", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsManaged { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this role is mentionable.
 	/// </summary>
 	[JsonProperty("mentionable", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsMentionable { get; internal set; }
 
 	/// <summary>
 	/// Gets the tags this role has.
 	/// </summary>
 	[JsonProperty("tags", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordRoleTags Tags { get; internal set; }
 
 	/// <summary>
 	/// Gets the role icon's hash.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
 	public string IconHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the role icon's url.
 	/// </summary>
 	[JsonIgnore]
 	public string IconUrl
 		=> !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ROLE_ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.png?size=64" : null;
 
 	/// <summary>
 	/// Gets the role unicode_emoji.
 	/// </summary>
 	[JsonProperty("unicode_emoji", NullValueHandling = NullValueHandling.Ignore)]
 	internal string UnicodeEmojiString;
 
 	/// <summary>
 	/// Gets the unicode emoji.
 	/// </summary>
 	public DiscordEmoji UnicodeEmoji
 		=> this.UnicodeEmojiString != null ? DiscordEmoji.FromName(this.Discord, $":{this.UnicodeEmojiString}:", false) : null;
 
 	[JsonIgnore]
 	internal ulong GuildId = 0;
 
 	/// <summary>
 	/// Gets the role flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public RoleFlags Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets a mention string for this role. If the role is mentionable, this string will mention all the users that belong to this role.
 	/// </summary>
 	public string Mention
 		=> Formatter.Mention(this);
 
 	#region Methods
 
 	/// <summary>
 	/// Modifies this role's position.
 	/// </summary>
 	/// <param name="position">New position</param>
 	/// <param name="reason">Reason why we moved it</param>
 	/// <returns></returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the role 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)
 	{
 		var roles = this.Discord.Guilds[this.GuildId].Roles.Values.OrderByDescending(xr => xr.Position)
 			.Select(x => new RestGuildRoleReorderPayload
 			{
 				RoleId = x.Id,
 				Position = x.Id == this.Id
 					? position
 					: x.Position <= position ? x.Position - 1 : x.Position
 			});
 
 		return this.Discord.ApiClient.ModifyGuildRolePositionAsync(this.GuildId, roles, reason);
 	}
 
 	/// <summary>
 	/// Updates this role.
 	/// </summary>
 	/// <param name="name">New role name.</param>
 	/// <param name="permissions">New role permissions.</param>
 	/// <param name="color">New role color.</param>
 	/// <param name="hoist">New role hoist.</param>
 	/// <param name="mentionable">Whether this role is mentionable.</param>
 	/// <param name="reason">Audit log reason.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the role 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(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildRoleAsync(this.GuildId, this.Id, name, permissions, color?.Value, hoist, mentionable, null, null, reason);
 
 	/// <summary>
 	/// Updates this role.
 	/// </summary>
 	/// <param name="action">The action.</param>
 	/// <exception cref = "Exceptions.UnauthorizedException" > Thrown when the client does not have the<see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the role 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<RoleEditModel> action)
 	{
 		var mdl = new RoleEditModel();
 		action(mdl);
 
 		var canContinue = true;
 		if ((mdl.Icon.HasValue && mdl.Icon.Value != null) || (mdl.UnicodeEmoji.HasValue && mdl.UnicodeEmoji.Value != null))
 			canContinue = this.Discord.Guilds[this.GuildId].Features.CanSetRoleIcons;
 
 		var iconb64 = Optional.FromNullable<string>(null);
 		if (mdl.Icon.HasValue && mdl.Icon.Value != null)
 			iconb64 = ImageTool.Base64FromStream(mdl.Icon);
 		else if (mdl.Icon.HasValue)
 			iconb64 = Optional.Some<string>(null);
 
 		var emoji = Optional.FromNullable<string>(null);
 
 		if (mdl.UnicodeEmoji.HasValue && mdl.UnicodeEmoji.Value != null)
 			emoji = mdl.UnicodeEmoji
 				.MapOrNull(e => e.Id == 0
 					? e.Name
 					: throw new ArgumentException("Emoji must be unicode"));
 		else if (mdl.UnicodeEmoji.HasValue)
 			emoji = Optional.Some<string>(null);
 
 		return canContinue ? this.Discord.ApiClient.ModifyGuildRoleAsync(this.GuildId, this.Id, mdl.Name, mdl.Permissions, mdl.Color?.Value, mdl.Hoist, mdl.Mentionable, iconb64, emoji, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify role icon. Guild needs boost tier two.");
 	}
 
 	/// <summary>
 	/// Deletes this role.
 	/// </summary>
 	/// <param name="reason">Reason as to why this role has been deleted.</param>
 	/// <returns></returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the role 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.DeleteRoleAsync(this.GuildId, this.Id, reason);
 
 	#endregion
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordRole"/> class.
 	/// </summary>
 	internal DiscordRole()
 	{ }
 
 	/// <summary>
 	/// Checks whether this role has specific permissions.
 	/// </summary>
 	/// <param name="permission">Permissions to check for.</param>
 	/// <returns>Whether the permissions are allowed or not.</returns>
 	public PermissionLevel CheckPermission(Permissions permission)
 		=> (this.Permissions & permission) != 0 ? PermissionLevel.Allowed : PermissionLevel.Unset;
 
 	/// <summary>
 	/// Returns a string representation of this role.
 	/// </summary>
 	/// <returns>String representation of this role.</returns>
 	public override string ToString()
 		=> $"Role {this.Id}; {this.Name}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordRole"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordRole"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordRole);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordRole"/> is equal to another <see cref="DiscordRole"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordRole"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordRole"/> is equal to this <see cref="DiscordRole"/>.</returns>
 	public bool Equals(DiscordRole e)
 		=> e switch
 		{
 			null => false,
 			_ => ReferenceEquals(this, e) || this.Id == e.Id
 		};
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordRole"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordRole"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordRole"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First role to compare.</param>
 	/// <param name="e2">Second role to compare.</param>
 	/// <returns>Whether the two roles are equal.</returns>
 	public static bool operator ==(DiscordRole e1, DiscordRole e2)
 		=> e1 is null == e2 is null
 		&& ((e1 is null && e2 is null) || e1.Id == e2.Id);
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordRole"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First role to compare.</param>
 	/// <param name="e2">Second role to compare.</param>
 	/// <returns>Whether the two roles are not equal.</returns>
 	public static bool operator !=(DiscordRole e1, DiscordRole e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Guild/ScheduledEvent/DiscordScheduledEvent.cs b/DisCatSharp/Entities/Guild/ScheduledEvent/DiscordScheduledEvent.cs
index 11486017b..c6d1bc259 100644
--- a/DisCatSharp/Entities/Guild/ScheduledEvent/DiscordScheduledEvent.cs
+++ b/DisCatSharp/Entities/Guild/ScheduledEvent/DiscordScheduledEvent.cs
@@ -1,327 +1,327 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents an scheduled event.
 /// </summary>
 public class DiscordScheduledEvent : SnowflakeObject, IEquatable<DiscordScheduledEvent>
 {
 	/// <summary>
 	/// Gets the guild id of the associated scheduled event.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild to which this scheduled event belongs.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.Discord.Guilds.TryGetValue(this.GuildId, out var guild) ? guild : null;
 
 	/// <summary>
 	/// Gets the associated channel.
 	/// </summary>
 	[JsonIgnore]
 	public Task<DiscordChannel> Channel
 		=> this.ChannelId.HasValue ? this.Discord.ApiClient.GetChannelAsync(this.ChannelId.Value) : null;
 
 	/// <summary>
 	/// Gets id of the associated channel id.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the user that created the scheduled event.
 	/// </summary>
 	[JsonProperty("creator_id")]
 	public ulong CreatorId { get; internal set; }
 
 	/// <summary>
 	/// Gets the user that created the scheduled event.
 	/// </summary>
 	[JsonProperty("creator")]
 	public DiscordUser Creator { get; internal set; }
 
 	/// <summary>
 	/// Gets the member that created the scheduled event.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMember CreatorMember
 		=> this.Guild.MembersInternal.TryGetValue(this.CreatorId, out var owner)
 			? owner
 			: this.Discord.ApiClient.GetGuildMemberAsync(this.GuildId, this.CreatorId).Result;
 
 	/// <summary>
 	/// Gets the name of the scheduled event.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of the scheduled event.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 	public string Description { get; internal set; }
 
 	/// <summary>
 	/// Gets this event's cover hash, when applicable.
 	/// </summary>
 	[JsonProperty("image", NullValueHandling = NullValueHandling.Include)]
 	public string CoverImageHash { get; internal set; }
 
 	/// <summary>
 	/// Gets this event's cover in url form.
 	/// </summary>
 	[JsonIgnore]
 	public string CoverImageUrl
 		=> !string.IsNullOrWhiteSpace(this.CoverImageHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.GUILD_EVENTS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.CoverImageHash}.png" : null;
 
 	/// <summary>
 	/// Gets the scheduled start time of the scheduled event.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? ScheduledStartTime
 		=> !string.IsNullOrWhiteSpace(this.ScheduledStartTimeRaw) && DateTimeOffset.TryParse(this.ScheduledStartTimeRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets the scheduled start time of the scheduled event as raw string.
 	/// </summary>
 	[JsonProperty("scheduled_start_time", NullValueHandling = NullValueHandling.Ignore)]
 	internal string ScheduledStartTimeRaw { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled end time of the scheduled event.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? ScheduledEndTime
 		=> !string.IsNullOrWhiteSpace(this.ScheduledEndTimeRaw) && DateTimeOffset.TryParse(this.ScheduledEndTimeRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets the scheduled end time of the scheduled event as raw string.
 	/// </summary>
 	[JsonProperty("scheduled_end_time", NullValueHandling = NullValueHandling.Ignore)]
 	internal string ScheduledEndTimeRaw { get; set; }
 
 	/// <summary>
 	/// Gets the privacy level of the scheduled event.
 	/// </summary>
 	[JsonProperty("privacy_level", NullValueHandling = NullValueHandling.Ignore)]
 	internal ScheduledEventPrivacyLevel PrivacyLevel { get; set; }
 
 	/// <summary>
 	/// Gets the status of the scheduled event.
 	/// </summary>
 	[JsonProperty("status", NullValueHandling = NullValueHandling.Ignore)]
 	public ScheduledEventStatus Status { get; internal set; }
 
 	/// <summary>
 	/// Gets the entity type.
 	/// </summary>
 	[JsonProperty("entity_type", NullValueHandling = NullValueHandling.Ignore)]
 	public ScheduledEventEntityType EntityType { get; internal set; }
 
 	/// <summary>
 	/// Gets id of the entity.
 	/// </summary>
 	[JsonProperty("entity_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? EntityId { get; internal set; }
 
 	/// <summary>
 	/// Gets metadata of the entity.
 	/// </summary>
 	[JsonProperty("entity_metadata", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordScheduledEventEntityMetadata EntityMetadata { get; internal set; }
 
 	/* This isn't used.
          * See https://github.com/discord/discord-api-docs/pull/3586#issuecomment-969066061.
          * Was originally for paid stages.
         /// <summary>
         /// Gets the sku ids of the scheduled event.
         /// </summary>
         [JsonProperty("sku_ids", NullValueHandling = NullValueHandling.Ignore)]
         public IReadOnlyList<ulong> SkuIds { get; internal set; }*/
 
 	/// <summary>
 	/// Gets the total number of users subscribed to the scheduled event.
 	/// </summary>
 	[JsonProperty("user_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int UserCount { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordScheduledEvent"/> class.
 	/// </summary>
 	internal DiscordScheduledEvent()
 	{ }
 
 	#region Methods
 
 	/// <summary>
 	/// Modifies the current scheduled event.
 	/// </summary>
 	/// <param name="action">Action to perform on this thread</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the event does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the event 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 ModifyAsync(Action<ScheduledEventEditModel> action)
 	{
 		var mdl = new ScheduledEventEditModel();
 		action(mdl);
 
 		Optional<ulong?> channelId = null;
 		if (this.EntityType == ScheduledEventEntityType.External || mdl.EntityType != ScheduledEventEntityType.External)
 			channelId = mdl.Channel
 				.MapOrNull<ulong?>(c => c.Type != ChannelType.Voice && c.Type != ChannelType.Stage
 					? throw new ArgumentException("Channel needs to be a voice or stage channel.")
 					: c.Id);
 
 		var coverb64 = ImageTool.Base64FromStream(mdl.CoverImage);
 
 		var scheduledEndTime = Optional<DateTimeOffset>.None;
 		if (mdl.ScheduledEndTime.HasValue && mdl.EntityType.HasValue ? mdl.EntityType == ScheduledEventEntityType.External : this.EntityType == ScheduledEventEntityType.External)
 			scheduledEndTime = mdl.ScheduledEndTime.Value;
 
 		await this.Discord.ApiClient.ModifyGuildScheduledEventAsync(this.GuildId, this.Id, channelId, this.EntityType == ScheduledEventEntityType.External ? new DiscordScheduledEventEntityMetadata(mdl.Location.Value) : null, mdl.Name, mdl.ScheduledStartTime, scheduledEndTime, mdl.Description, mdl.EntityType, mdl.Status, coverb64, mdl.AuditLogReason);
 	}
 
 	/// <summary>
 	/// Starts the current scheduled event.
 	/// </summary>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the event does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the event 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> StartAsync(string reason = null)
 		=> this.Status == ScheduledEventStatus.Scheduled ? await this.Discord.ApiClient.ModifyGuildScheduledEventStatusAsync(this.GuildId, this.Id, ScheduledEventStatus.Active, reason) : throw new InvalidOperationException("You can only start scheduled events");
 
 	/// <summary>
 	/// Cancels the current scheduled event.
 	/// </summary>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the event does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the event 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> CancelAsync(string reason = null)
 		=> this.Status == ScheduledEventStatus.Scheduled ? await this.Discord.ApiClient.ModifyGuildScheduledEventStatusAsync(this.GuildId, this.Id, ScheduledEventStatus.Canceled, reason) : throw new InvalidOperationException("You can only cancel scheduled events");
 
 	/// <summary>
 	/// Ends the current scheduled event.
 	/// </summary>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the event does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the event 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> EndAsync(string reason = null)
 		=> this.Status == ScheduledEventStatus.Active ? await this.Discord.ApiClient.ModifyGuildScheduledEventStatusAsync(this.GuildId, this.Id, ScheduledEventStatus.Completed, reason) : throw new InvalidOperationException("You can only stop active events");
 
 	/// <summary>
 	/// Gets a list of users RSVP'd to the scheduled event.
 	/// </summary>
 	/// <param name="limit">The limit how many users to receive from the event. Defaults to 100. Max 100.</param>
 	/// <param name="before">Get results of <see cref="DiscordScheduledEventUser"/> before the given snowflake.</param>
 	/// <param name="after">Get results of <see cref="DiscordScheduledEventUser"/> after the given snowflake.</param>
 	/// <param name="withMember">Whether to include guild member data.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the correct permissions.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the event does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the correct permissions.</exception>
+	/// <exception cref="NotFoundException">Thrown when the event 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<IReadOnlyDictionary<ulong, DiscordScheduledEventUser>> GetUsersAsync(int? limit = null, ulong? before = null, ulong? after = null, bool? withMember = null)
 		=> await this.Discord.ApiClient.GetGuildScheduledEventRspvUsersAsync(this.GuildId, this.Id, limit, before, after, withMember);
 
 	/// <summary>
 	/// Deletes a scheduled event.
 	/// </summary>
 	/// <param name="reason">The audit log reason.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the event does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEvents"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the event 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 DeleteAsync(string reason = null)
 		=> await this.Discord.ApiClient.DeleteGuildScheduledEventAsync(this.GuildId, this.Id, reason);
 
 	#endregion
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordScheduledEvent"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordScheduledEvent"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordScheduledEvent);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordScheduledEvent"/> is equal to another <see cref="DiscordScheduledEvent"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordScheduledEvent"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordScheduledEvent"/> is equal to this <see cref="DiscordScheduledEvent"/>.</returns>
 	public bool Equals(DiscordScheduledEvent e)
 		=> e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordScheduledEvent"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordScheduledEvent"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordScheduledEvent"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First event to compare.</param>
 	/// <param name="e2">Second event to compare.</param>
 	/// <returns>Whether the two events are equal.</returns>
 	public static bool operator ==(DiscordScheduledEvent e1, DiscordScheduledEvent 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="DiscordScheduledEvent"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First event to compare.</param>
 	/// <param name="e2">Second event to compare.</param>
 	/// <returns>Whether the two events are not equal.</returns>
 	public static bool operator !=(DiscordScheduledEvent e1, DiscordScheduledEvent e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordFollowupMessageBuilder.cs b/DisCatSharp/Entities/Interaction/DiscordFollowupMessageBuilder.cs
index f43e8a54c..925b7e2fc 100644
--- a/DisCatSharp/Entities/Interaction/DiscordFollowupMessageBuilder.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordFollowupMessageBuilder.cs
@@ -1,313 +1,313 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Constructs a followup message to an interaction.
 /// </summary>
 public sealed class DiscordFollowupMessageBuilder
 {
 	/// <summary>
 	/// Whether this followup message is text-to-speech.
 	/// </summary>
 	public bool IsTts { get; set; }
 
 	/// <summary>
 	/// Whether this followup message should be ephemeral.
 	/// </summary>
 	public bool IsEphemeral { get; set; }
 
 	/// <summary>
 	/// Indicates this message is ephemeral.
 	/// </summary>
 	internal int? Flags
 		=> this.IsEphemeral ? 64 : null;
 
 	/// <summary>
 	/// Message to send on followup message.
 	/// </summary>
 	public string Content
 	{
 		get => this._content;
 		set
 		{
 			if (value != null && value.Length > 2000)
 				throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
 			this._content = value;
 		}
 	}
 	private string _content;
 
 	/// <summary>
 	/// Embeds to send on followup message.
 	/// </summary>
 	public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 	private readonly List<DiscordEmbed> _embeds = new();
 
 	/// <summary>
 	/// Files to send on this followup message.
 	/// </summary>
 	public IReadOnlyList<DiscordMessageFile> Files => this._files;
 	private readonly List<DiscordMessageFile> _files = new();
 
 	/// <summary>
 	/// Components to send on this followup message.
 	/// </summary>
 	public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
 	private readonly List<DiscordActionRowComponent> _components = new();
 
 	/// <summary>
 	/// Mentions to send on this followup message.
 	/// </summary>
 	public IReadOnlyList<IMention> Mentions => this._mentions;
 	private readonly List<IMention> _mentions = new();
 
 
 	/// <summary>
 	/// Appends a collection of components to the message.
 	/// </summary>
 	/// <param name="components">The collection of components to add.</param>
 	/// <returns>The builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException"><paramref name="components"/> contained more than 5 components.</exception>
+	/// <exception cref="ArgumentException"><paramref name="components"/> contained more than 5 components.</exception>
 	public DiscordFollowupMessageBuilder AddComponents(params DiscordComponent[] components)
 		=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 	/// <summary>
 	/// Appends several rows of components to the message
 	/// </summary>
 	/// <param name="components">The rows of components to add, holding up to five each.</param>
 	/// <returns></returns>
 	public DiscordFollowupMessageBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 	{
 		var ara = components.ToArray();
 
 		if (ara.Length + this._components.Count > 5)
 			throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 		foreach (var ar in ara)
 			this._components.Add(ar);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Appends a collection of components to the message.
 	/// </summary>
 	/// <param name="components">The collection of components to add.</param>
 	/// <returns>The builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException"><paramref name="components"/> contained more than 5 components.</exception>
+	/// <exception cref="ArgumentException"><paramref name="components"/> contained more than 5 components.</exception>
 	public DiscordFollowupMessageBuilder AddComponents(IEnumerable<DiscordComponent> components)
 	{
 		var compArr = components.ToArray();
 		var count = compArr.Length;
 
 		if (count > 5)
 			throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 		var arc = new DiscordActionRowComponent(compArr);
 		this._components.Add(arc);
 		return this;
 	}
 	/// <summary>
 	/// Indicates if the followup message must use text-to-speech.
 	/// </summary>
 	/// <param name="tts">Text-to-speech</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder WithTts(bool tts)
 	{
 		this.IsTts = tts;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the message to send with the followup message..
 	/// </summary>
 	/// <param name="content">Message to send.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder WithContent(string content)
 	{
 		this.Content = content;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds an embed to the followup message.
 	/// </summary>
 	/// <param name="embed">Embed to add.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddEmbed(DiscordEmbed embed)
 	{
 		this._embeds.Add(embed);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given embeds to the followup message.
 	/// </summary>
 	/// <param name="embeds">Embeds to add.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 	{
 		this._embeds.AddRange(embeds);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a file to the followup message.
 	/// </summary>
 	/// <param name="filename">Name of the file.</param>
 	/// <param name="data">File data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count >= 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == filename))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(filename, data, data.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(filename, data, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="stream">The Stream to the file.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count >= 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == stream.Name))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given files to the followup message.
 	/// </summary>
 	/// <param name="files">Dictionary of file name and file data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 	{
 		if (this.Files.Count + files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		foreach (var file in files)
 		{
 			if (this._files.Any(x => x.FileName == file.Key))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 			else
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
 		}
 
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mention to the mentions to parse, etc. with the followup message.
 	/// </summary>
 	/// <param name="mention">Mention to add.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddMention(IMention mention)
 	{
 		this._mentions.Add(mention);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mentions to the mentions to parse, etc. with the followup message.
 	/// </summary>
 	/// <param name="mentions">Mentions to add.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordFollowupMessageBuilder AddMentions(IEnumerable<IMention> mentions)
 	{
 		this._mentions.AddRange(mentions);
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the followup message to be ephemeral.
 	/// </summary>
 	/// <param name="ephemeral">Whether the followup should be ephemeral. Defaults to true.</param>
 	public DiscordFollowupMessageBuilder AsEphemeral(bool ephemeral = true)
 	{
 		this.IsEphemeral = ephemeral;
 		return this;
 	}
 
 	/// <summary>
 	/// Clears all message components on this builder.
 	/// </summary>
 	public void ClearComponents()
 		=> this._components.Clear();
 
 	/// <summary>
 	/// Allows for clearing the Followup Message builder so that it can be used again to send a new message.
 	/// </summary>
 	public void Clear()
 	{
 		this.Content = "";
 		this._embeds.Clear();
 		this.IsTts = false;
 		this._mentions.Clear();
 		this._files.Clear();
 		this.IsEphemeral = false;
 		this._components.Clear();
 	}
 
 	/// <summary>
 	/// Validates the builder.
 	/// </summary>
 	internal void Validate()
 	{
 		if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && !this.Embeds.Any())
 			throw new ArgumentException("You must specify content, an embed, or at least one file.");
 	}
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordInteractionModalBuilder.cs b/DisCatSharp/Entities/Interaction/DiscordInteractionModalBuilder.cs
index 9e5ca590d..4e2263530 100644
--- a/DisCatSharp/Entities/Interaction/DiscordInteractionModalBuilder.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordInteractionModalBuilder.cs
@@ -1,183 +1,183 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Constructs an interaction modal response.
 /// </summary>
 public sealed class DiscordInteractionModalBuilder
 {
 	/// <summary>
 	/// Title of modal.
 	/// </summary>
 	public string Title
 	{
 		get => this._title;
 		set
 		{
 			if (value != null && value.Length > 128)
 				throw new ArgumentException("Title length cannot exceed 128 characters.", nameof(value));
 			this._title = value;
 		}
 	}
 	private string _title;
 
 	/// <summary>
 	/// Custom id of modal.
 	/// </summary>
 	public string CustomId { get; set; }
 
 	/// <summary>
 	/// Components to send on this interaction response.
 	/// </summary>
 	public IReadOnlyList<DiscordActionRowComponent> ModalComponents => this._components;
 	private readonly List<DiscordActionRowComponent> _components = new();
 
 	/// <summary>
 	/// Constructs a new empty interaction modal builder.
 	/// </summary>
 	public DiscordInteractionModalBuilder(string title = null, string customId = null)
 	{
 		this.Title = title ?? "Title";
 		this.CustomId = customId ?? Guid.NewGuid().ToString();
 	}
 
 	public DiscordInteractionModalBuilder WithTitle(string title)
 	{
 		this.Title = title;
 		return this;
 	}
 
 	public DiscordInteractionModalBuilder WithCustomId(string customId)
 	{
 		this.CustomId = customId;
 		return this;
 	}
 
 	/// <summary>
 	/// Appends a collection of text components to the builder. Each call will append to a new row.
 	/// </summary>
 	/// <param name="components">The components to append. Up to five.</param>
 	/// <returns>The current builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException">Thrown when passing more than 5 components.</exception>
+	/// <exception cref="ArgumentException">Thrown when passing more than 5 components.</exception>
 	public DiscordInteractionModalBuilder AddTextComponents(params DiscordTextComponent[] components)
 		=> this.AddModalComponents(components);
 
 	/// <summary>
 	/// Appends a collection of select components to the builder. Each call will append to a new row.
 	/// </summary>
 	/// <param name="components">The components to append. Up to five.</param>
 	/// <returns>The current builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException">Thrown when passing more than 5 components.</exception>
+	/// <exception cref="ArgumentException">Thrown when passing more than 5 components.</exception>
 	public DiscordInteractionModalBuilder AddSelectComponents(params DiscordSelectComponent[] components)
 		=> this.AddModalComponents(components);
 
 	/// <summary>
 	/// Appends a text component to the builder.
 	/// </summary>
 	/// <param name="component">The component to append.</param>
 	/// <returns>The current builder to chain calls with.</returns>
 	public DiscordInteractionModalBuilder AddTextComponent(DiscordTextComponent component)
 		=> this.AddModalComponents(component);
 
 	/// <summary>
 	/// Appends a select component to the builder.
 	/// </summary>
 	/// <param name="component">The component to append.</param>
 	/// <returns>The current builder to chain calls with.</returns>
 	public DiscordInteractionModalBuilder AddSelectComponent(DiscordSelectComponent component)
 		=> this.AddModalComponents(component);
 
 	/// <summary>
 	/// Appends a collection of components to the builder.
 	/// </summary>
 	/// <param name="components">The components to append. Up to five.</param>
 	/// <returns>The current builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException">Thrown when passing more than 5 components.</exception>
+	/// <exception cref="ArgumentException">Thrown when passing more than 5 components.</exception>
 	public DiscordInteractionModalBuilder AddModalComponents(params DiscordComponent[] components)
 	{
 		var ara = components.ToArray();
 		if (ara.Length > 5)
 
 			throw new ArgumentException("You can only add 5 components to modals.");
 
 		if (this._components.Count + ara.Length > 5)
 			throw new ArgumentException($"You try to add too many components. We already have {this._components.Count}.");
 
 		foreach (var ar in ara)
 			this._components.Add(new DiscordActionRowComponent(new List<DiscordComponent>() { ar }));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Appends several rows of components to the message
 	/// </summary>
 	/// <param name="components">The rows of components to add, holding up to five each.</param>
 	/// <returns>The current builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException">Thrown when passing more than 5 components.</exception>
+	/// <exception cref="ArgumentException">Thrown when passing more than 5 components.</exception>
 	public DiscordInteractionModalBuilder AddModalComponents(IEnumerable<DiscordActionRowComponent> components)
 	{
 		var ara = components.ToArray();
 
 		if (ara.Length + this._components.Count > 5)
 			throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 		foreach (var ar in ara)
 			this._components.Add(ar);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Appends a collection of components to the builder. Each call will append to a new row.
 	/// </summary>
 	/// <param name="component">The component to append.</param>
 	/// <returns>The current builder to chain calls with.</returns>
 	internal DiscordInteractionModalBuilder AddModalComponents(DiscordComponent component)
 	{
 		this._components.Add(new DiscordActionRowComponent(new List<DiscordComponent>() { component }));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Clears all message components on this builder.
 	/// </summary>
 	public void ClearComponents()
 		=> this._components.Clear();
 
 	/// <summary>
 	/// Allows for clearing the Interaction Response Builder so that it can be used again to send a new response.
 	/// </summary>
 	public void Clear()
 	{
 		this._components.Clear();
 		this.Title = null;
 		this.CustomId = null;
 	}
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordInteractionResponseBuilder.cs b/DisCatSharp/Entities/Interaction/DiscordInteractionResponseBuilder.cs
index 23e377bcd..ee8f4586b 100644
--- a/DisCatSharp/Entities/Interaction/DiscordInteractionResponseBuilder.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordInteractionResponseBuilder.cs
@@ -1,352 +1,352 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Constructs an interaction response.
 /// </summary>
 public sealed class DiscordInteractionResponseBuilder
 {
 	/// <summary>
 	/// Whether this interaction response is text-to-speech.
 	/// </summary>
 	public bool IsTts { get; set; }
 
 	/// <summary>
 	/// Whether this interaction response should be ephemeral.
 	/// </summary>
 	public bool IsEphemeral { get; set; }
 
 	/// <summary>
 	/// Content of the message to send.
 	/// </summary>
 	public string Content
 	{
 		get => this._content;
 		set
 		{
 			if (value != null && value.Length > 2000)
 				throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
 			this._content = value;
 		}
 	}
 	private string _content;
 
 	/// <summary>
 	/// Embeds to send on this interaction response.
 	/// </summary>
 	public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 	private readonly List<DiscordEmbed> _embeds = new();
 
 
 	/// <summary>
 	/// Files to send on this interaction response.
 	/// </summary>
 	public IReadOnlyList<DiscordMessageFile> Files => this._files;
 	private readonly List<DiscordMessageFile> _files = new();
 
 	/// <summary>
 	/// Components to send on this interaction response.
 	/// </summary>
 	public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
 	private readonly List<DiscordActionRowComponent> _components = new();
 
 	/// <summary>
 	/// The choices to send on this interaction response.
 	/// Mutually exclusive with content, embed, and components.
 	/// </summary>
 	public IReadOnlyList<DiscordApplicationCommandAutocompleteChoice> Choices => this._choices;
 	private readonly List<DiscordApplicationCommandAutocompleteChoice> _choices = new();
 
 
 	/// <summary>
 	/// Mentions to send on this interaction response.
 	/// </summary>
 	public IEnumerable<IMention> Mentions => this._mentions;
 	private readonly List<IMention> _mentions = new();
 
 	/// <summary>
 	/// Constructs a new empty interaction response builder.
 	/// </summary>
 	public DiscordInteractionResponseBuilder() { }
 
 
 	/// <summary>
 	/// Constructs a new <see cref="DiscordInteractionResponseBuilder"/> based on an existing <see cref="DisCatSharp.Entities.DiscordMessageBuilder"/>.
 	/// </summary>
 	/// <param name="builder">The builder to copy.</param>
 	public DiscordInteractionResponseBuilder(DiscordMessageBuilder builder)
 	{
 		this._content = builder.Content;
 		this._mentions = builder.Mentions;
 		this._embeds.AddRange(builder.Embeds);
 		this._components.AddRange(builder.Components);
 	}
 
 
 	/// <summary>
 	/// Appends a collection of components to the builder. Each call will append to a new row.
 	/// </summary>
 	/// <param name="components">The components to append. Up to five.</param>
 	/// <returns>The current builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException">Thrown when passing more than 5 components.</exception>
+	/// <exception cref="ArgumentException">Thrown when passing more than 5 components.</exception>
 	public DiscordInteractionResponseBuilder AddComponents(params DiscordComponent[] components)
 		=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 	/// <summary>
 	/// Appends several rows of components to the message
 	/// </summary>
 	/// <param name="components">The rows of components to add, holding up to five each.</param>
 	/// <returns></returns>
 	public DiscordInteractionResponseBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 	{
 		var ara = components.ToArray();
 
 		if (ara.Length + this._components.Count > 5)
 			throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 		foreach (var ar in ara)
 			this._components.Add(ar);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Appends a collection of components to the builder. Each call will append to a new row.
 	/// </summary>
 	/// <param name="components">The components to append. Up to five.</param>
 	/// <returns>The current builder to chain calls with.</returns>
-	/// <exception cref="System.ArgumentException">Thrown when passing more than 5 components.</exception>
+	/// <exception cref="ArgumentException">Thrown when passing more than 5 components.</exception>
 	public DiscordInteractionResponseBuilder AddComponents(IEnumerable<DiscordComponent> components)
 	{
 		var compArr = components.ToArray();
 		var count = compArr.Length;
 
 		if (count > 5)
 			throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 		var arc = new DiscordActionRowComponent(compArr);
 		this._components.Add(arc);
 		return this;
 	}
 
 	/// <summary>
 	/// Indicates if the interaction response will be text-to-speech.
 	/// </summary>
 	/// <param name="tts">Text-to-speech</param>
 	public DiscordInteractionResponseBuilder WithTts(bool tts)
 	{
 		this.IsTts = tts;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the interaction response to be ephemeral.
 	/// </summary>
 	/// <param name="ephemeral">Whether the response should be ephemeral. Defaults to true.</param>
 	public DiscordInteractionResponseBuilder AsEphemeral(bool ephemeral = true)
 	{
 		this.IsEphemeral = ephemeral;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the content of the message to send.
 	/// </summary>
 	/// <param name="content">Content to send.</param>
 	public DiscordInteractionResponseBuilder WithContent(string content)
 	{
 		this.Content = content;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds an embed to send with the interaction response.
 	/// </summary>
 	/// <param name="embed">Embed to add.</param>
 	public DiscordInteractionResponseBuilder AddEmbed(DiscordEmbed embed)
 	{
 		if (embed != null)
 			this._embeds.Add(embed); // Interactions will 400 silently //
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given embeds to send with the interaction response.
 	/// </summary>
 	/// <param name="embeds">Embeds to add.</param>
 	public DiscordInteractionResponseBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 	{
 		this._embeds.AddRange(embeds);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a file to the interaction response.
 	/// </summary>
 	/// <param name="filename">Name of the file.</param>
 	/// <param name="data">File data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordInteractionResponseBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count >= 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == filename))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(filename, data, data.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(filename, data, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="stream">The Stream to the file.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordInteractionResponseBuilder AddFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count >= 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == stream.Name))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given files to the interaction response builder.
 	/// </summary>
 	/// <param name="files">Dictionary of file name and file data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <returns>The builder to chain calls with.</returns>
 	public DiscordInteractionResponseBuilder AddFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 	{
 		if (this.Files.Count + files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		foreach (var file in files)
 		{
 			if (this._files.Any(x => x.FileName == file.Key))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 			else
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
 		}
 
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mention to the mentions to parse, etc. with the interaction response.
 	/// </summary>
 	/// <param name="mention">Mention to add.</param>
 	public DiscordInteractionResponseBuilder AddMention(IMention mention)
 	{
 		this._mentions.Add(mention);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mentions to the mentions to parse, etc. with the interaction response.
 	/// </summary>
 	/// <param name="mentions">Mentions to add.</param>
 	public DiscordInteractionResponseBuilder AddMentions(IEnumerable<IMention> mentions)
 	{
 		this._mentions.AddRange(mentions);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a single auto-complete choice to the builder.
 	/// </summary>
 	/// <param name="choice">The choice to add.</param>
 	/// <returns>The current builder to chain calls with.</returns>
 	public DiscordInteractionResponseBuilder AddAutoCompleteChoice(DiscordApplicationCommandAutocompleteChoice choice)
 	{
 		this._choices.Add(choice);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds auto-complete choices to the builder.
 	/// </summary>
 	/// <param name="choices">The choices to add.</param>
 	/// <returns>The current builder to chain calls with.</returns>
 	public DiscordInteractionResponseBuilder AddAutoCompleteChoices(IEnumerable<DiscordApplicationCommandAutocompleteChoice> choices)
 	{
 		this._choices.AddRange(choices);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds auto-complete choices to the builder.
 	/// </summary>
 	/// <param name="choices">The choices to add.</param>
 	/// <returns>The current builder to chain calls with.</returns>
 	public DiscordInteractionResponseBuilder AddAutoCompleteChoices(params DiscordApplicationCommandAutocompleteChoice[] choices)
 		=> this.AddAutoCompleteChoices((IEnumerable<DiscordApplicationCommandAutocompleteChoice>)choices);
 
 	/// <summary>
 	/// Clears all message components on this builder.
 	/// </summary>
 	public void ClearComponents()
 		=> this._components.Clear();
 
 	/// <summary>
 	/// Allows for clearing the Interaction Response Builder so that it can be used again to send a new response.
 	/// </summary>
 	public void Clear()
 	{
 		this.Content = "";
 		this._embeds.Clear();
 		this.IsTts = false;
 		this.IsEphemeral = false;
 		this._mentions.Clear();
 		this._components.Clear();
 		this._choices.Clear();
 		this._files.Clear();
 	}
 }
diff --git a/DisCatSharp/Entities/Invite/DiscordInvite.cs b/DisCatSharp/Entities/Invite/DiscordInvite.cs
index 5c10f33f3..acc764fda 100644
--- a/DisCatSharp/Entities/Invite/DiscordInvite.cs
+++ b/DisCatSharp/Entities/Invite/DiscordInvite.cs
@@ -1,198 +1,198 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord invite.
 /// </summary>
 public class DiscordInvite
 {
 	/// <summary>
 	/// Gets the base client.
 	/// </summary>
 	internal BaseDiscordClient Discord { get; set; }
 
 	/// <summary>
 	/// Gets the invite's code.
 	/// </summary>
 	[JsonProperty("code", NullValueHandling = NullValueHandling.Ignore)]
 	public string Code { get; internal set; }
 
 	/// <summary>
 	/// Gets the invite's url.
 	/// </summary>
 	[JsonIgnore]
 	public string Url => DiscordDomain.GetDomain(CoreDomain.DiscordShortlink).Url + "/" + this.Code;
 
 	/// <summary>
 	/// Gets the invite's url as Uri.
 	/// </summary>
 	[JsonIgnore]
 	public Uri Uri => new(this.Url);
 
 	/// <summary>
 	/// Gets the guild this invite is for.
 	/// </summary>
 	[JsonProperty("guild", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordInviteGuild Guild { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel this invite is for.
 	/// </summary>
 	[JsonProperty("channel", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordInviteChannel Channel { get; internal set; }
 
 	/// <summary>
 	/// Gets the target type for the voice channel this invite is for.
 	/// </summary>
 	[JsonProperty("target_type", NullValueHandling = NullValueHandling.Ignore)]
 	public TargetType? TargetType { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of this invite.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public InviteType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the user that is currently livestreaming.
 	/// </summary>
 	[JsonProperty("target_user", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser TargetUser { get; internal set; }
 
 	/// <summary>
 	/// Gets the embedded partial application to open for this voice channel.
 	/// </summary>
 	[JsonProperty("target_application", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordApplication TargetApplication { get; internal set; }
 
 	/// <summary>
 	/// Gets the approximate guild online member count for the invite.
 	/// </summary>
 	[JsonProperty("approximate_presence_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ApproximatePresenceCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the approximate guild total member count for the invite.
 	/// </summary>
 	[JsonProperty("approximate_member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ApproximateMemberCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the user who created the invite.
 	/// </summary>
 	[JsonProperty("inviter", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser Inviter { get; internal set; }
 
 	/// <summary>
 	/// Gets the number of times this invite has been used.
 	/// </summary>
 	[JsonProperty("uses", NullValueHandling = NullValueHandling.Ignore)]
 	public int Uses { get; internal set; }
 
 	/// <summary>
 	/// Gets the max number of times this invite can be used.
 	/// </summary>
 	[JsonProperty("max_uses", NullValueHandling = NullValueHandling.Ignore)]
 	public int MaxUses { get; internal set; }
 
 	/// <summary>
 	/// Gets duration in seconds after which the invite expires.
 	/// </summary>
 	[JsonProperty("max_age", NullValueHandling = NullValueHandling.Ignore)]
 	public int MaxAge { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this invite only grants temporary membership.
 	/// </summary>
 	[JsonProperty("temporary", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsTemporary { get; internal set; }
 
 	/// <summary>
 	/// Gets the date and time this invite was created.
 	/// </summary>
 	[JsonProperty("created_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset CreatedAt { get; internal set; }
 
 	/// <summary>
 	/// Gets the date and time when this invite expires.
 	/// </summary>
 	[JsonProperty("expires_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset ExpiresAt { get; internal set; }
 
 	/// <summary>
 	/// Gets the date and time when this invite got expired.
 	/// </summary>
 	[JsonProperty("expired_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset ExpiredAt { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this invite is revoked.
 	/// </summary>
 	[JsonProperty("revoked", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsRevoked { get; internal set; }
 
 	/// <summary>
 	/// Gets the stage instance this invite is for.
 	/// </summary>
 	[JsonProperty("stage_instance", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordInviteStage Stage { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild scheduled event data for the invite.
 	/// </summary>
 	[JsonProperty("guild_scheduled_event", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordScheduledEvent GuildScheduledEvent { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordInvite"/> class.
 	/// </summary>
 	internal DiscordInvite()
 	{ }
 
 	/// <summary>
 	/// Deletes the invite.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns></returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission or the <see cref="Permissions.ManageGuild"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission or the <see cref="Permissions.ManageGuild"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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> DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteInviteAsync(this.Code, reason);
 
 	/// <summary>
 	/// Converts this invite into an invite link.
 	/// </summary>
 	/// <returns>A discord.gg invite link.</returns>
 	public override string ToString()
 		=> $"{DiscordDomain.GetDomain(CoreDomain.DiscordShortlink).Url}/{this.Code}";
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessage.cs b/DisCatSharp/Entities/Message/DiscordMessage.cs
index c500200ea..1fbe6f3e0 100644
--- a/DisCatSharp/Entities/Message/DiscordMessage.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessage.cs
@@ -1,878 +1,878 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord text message.
 /// </summary>
 public class DiscordMessage : SnowflakeObject, IEquatable<DiscordMessage>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 	/// </summary>
 	internal DiscordMessage()
 	{
 		this._attachmentsLazy = new Lazy<IReadOnlyList<DiscordAttachment>>(() => new ReadOnlyCollection<DiscordAttachment>(this.AttachmentsInternal));
 		this._embedsLazy = new Lazy<IReadOnlyList<DiscordEmbed>>(() => new ReadOnlyCollection<DiscordEmbed>(this.EmbedsInternal));
 		this._mentionedChannelsLazy = new Lazy<IReadOnlyList<DiscordChannel>>(() => this.MentionedChannelsInternal != null
 				? new ReadOnlyCollection<DiscordChannel>(this.MentionedChannelsInternal)
 				: Array.Empty<DiscordChannel>());
 		this._mentionedRolesLazy = new Lazy<IReadOnlyList<DiscordRole>>(() => this.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(this.MentionedRolesInternal) : Array.Empty<DiscordRole>());
 		this.MentionedUsersLazy = new Lazy<IReadOnlyList<DiscordUser>>(() => new ReadOnlyCollection<DiscordUser>(this.MentionedUsersInternal));
 		this._reactionsLazy = new Lazy<IReadOnlyList<DiscordReaction>>(() => new ReadOnlyCollection<DiscordReaction>(this.ReactionsInternal));
 		this._stickersLazy = new Lazy<IReadOnlyList<DiscordSticker>>(() => new ReadOnlyCollection<DiscordSticker>(this.StickersInternal));
 		this._jumpLink = new Lazy<Uri>(() =>
 		{
 			string gid = null;
 			if (this.Channel != null)
 				gid = this.Channel is DiscordDmChannel
 					? "@me"
 					: this.Channel is DiscordThreadChannel
 					? this.INTERNAL_THREAD.GuildId.Value.ToString(CultureInfo.InvariantCulture)
 					: this.Channel.GuildId.Value.ToString(CultureInfo.InvariantCulture);
 
 			var cid = this.ChannelId.ToString(CultureInfo.InvariantCulture);
 			var mid = this.Id.ToString(CultureInfo.InvariantCulture);
 
 			return new Uri($"https://{(this.Discord.Configuration.UseCanary ? "canary.discord.com" : this.Discord.Configuration.UsePtb ? "ptb.discord.com" : "discord.com")}/channels/{gid}/{cid}/{mid}");
 		});
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 	/// </summary>
 	/// <param name="other">The other message.</param>
 	internal DiscordMessage(DiscordMessage other)
 		: this()
 	{
 		this.Discord = other.Discord;
 
 		this.AttachmentsInternal = other.AttachmentsInternal; // the attachments cannot change, thus no need to copy and reallocate.
 		this.EmbedsInternal = new List<DiscordEmbed>(other.EmbedsInternal);
 
 		if (other.MentionedChannelsInternal != null)
 			this.MentionedChannelsInternal = new List<DiscordChannel>(other.MentionedChannelsInternal);
 		if (other.MentionedRolesInternal != null)
 			this.MentionedRolesInternal = new List<DiscordRole>(other.MentionedRolesInternal);
 		if (other.MentionedRoleIds != null)
 			this.MentionedRoleIds = new List<ulong>(other.MentionedRoleIds);
 		this.MentionedUsersInternal = new List<DiscordUser>(other.MentionedUsersInternal);
 		this.ReactionsInternal = new List<DiscordReaction>(other.ReactionsInternal);
 		this.StickersInternal = new List<DiscordSticker>(other.StickersInternal);
 
 		this.Author = other.Author;
 		this.ChannelId = other.ChannelId;
 		this.Content = other.Content;
 		this.EditedTimestampRaw = other.EditedTimestampRaw;
 		this.Id = other.Id;
 		this.IsTts = other.IsTts;
 		this.MessageType = other.MessageType;
 		this.Pinned = other.Pinned;
 		this.TimestampRaw = other.TimestampRaw;
 		this.WebhookId = other.WebhookId;
 	}
 
 	/// <summary>
 	/// Gets the channel in which the message was sent.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Channel
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedChannel(this.ChannelId) ?? this._channel;
 		internal set => this._channel = value;
 	}
 
 	private DiscordChannel _channel;
 
 	/// <summary>
 	/// Gets the thread in which the message was sent.
 	/// </summary>
 	[JsonIgnore]
 	private DiscordThreadChannel INTERNAL_THREAD
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedThread(this.ChannelId) ?? this._thread;
 		set => this._thread = value;
 	}
 
 	private DiscordThreadChannel _thread;
 
 	/// <summary>
 	/// Gets the ID of the channel in which the message was sent.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the components this message was sent with.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordActionRowComponent> Components { get; internal set; }
 
 	/// <summary>
 	/// Gets the user or member that sent the message.
 	/// </summary>
 	[JsonProperty("author", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser Author { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's creation timestamp.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset Timestamp
 		=> !string.IsNullOrWhiteSpace(this.TimestampRaw) && DateTimeOffset.TryParse(this.TimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : this.CreationTimestamp;
 
 	/// <summary>
 	/// Gets the message's creation timestamp as raw string.
 	/// </summary>
 	[JsonProperty("timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string TimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the message's edit timestamp. Will be null if the message was not edited.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? EditedTimestamp
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw) && DateTimeOffset.TryParse(this.EditedTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			(DateTimeOffset?)dto : null;
 
 	/// <summary>
 	/// Gets the message's edit timestamp as raw string. Will be null if the message was not edited.
 	/// </summary>
 	[JsonProperty("edited_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string EditedTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets whether this message was edited.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsEdited
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw);
 
 	/// <summary>
 	/// Gets whether the message is a text-to-speech message.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsTts { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message mentions everyone.
 	/// </summary>
 	[JsonProperty("mention_everyone", NullValueHandling = NullValueHandling.Ignore)]
 	public bool MentionEveryone { get; internal set; }
 
 	/// <summary>
 	/// Gets users or members mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordUser> MentionedUsers
 		=> this.MentionedUsersLazy.Value;
 
 	[JsonProperty("mentions", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordUser> MentionedUsersInternal;
 	[JsonIgnore]
 	internal readonly Lazy<IReadOnlyList<DiscordUser>> MentionedUsersLazy;
 
 	// TODO: this will probably throw an exception in DMs since it tries to wrap around a null List...
 	// this is probably low priority but need to find out a clean way to solve it...
 	/// <summary>
 	/// Gets roles mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordRole> MentionedRoles
 		=> this._mentionedRolesLazy.Value;
 
 	[JsonIgnore]
 	internal List<DiscordRole> MentionedRolesInternal;
 
 	[JsonProperty("mention_roles")]
 	internal List<ulong> MentionedRoleIds;
 
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordRole>> _mentionedRolesLazy;
 
 	/// <summary>
 	/// Gets channels mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordChannel> MentionedChannels
 		=> this._mentionedChannelsLazy.Value;
 
 	[JsonIgnore]
 	internal List<DiscordChannel> MentionedChannelsInternal;
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordChannel>> _mentionedChannelsLazy;
 
 	/// <summary>
 	/// Gets files attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordAttachment> Attachments
 		=> this._attachmentsLazy.Value;
 
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordAttachment> AttachmentsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordAttachment>> _attachmentsLazy;
 
 	/// <summary>
 	/// Gets embeds attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordEmbed> Embeds
 		=> this._embedsLazy.Value;
 
 	[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordEmbed> EmbedsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordEmbed>> _embedsLazy;
 
 	/// <summary>
 	/// Gets reactions used on this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordReaction> Reactions
 		=> this._reactionsLazy.Value;
 
 	[JsonProperty("reactions", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordReaction> ReactionsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordReaction>> _reactionsLazy;
 
 	/// <summary>
 	/// Gets the nonce sent with the message, if the message was sent by the client.
 	/// </summary>
 	[JsonProperty("nonce", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nonce { get; internal set; }
 
 
 	/// <summary>
 	/// Gets whether the message is pinned.
 	/// </summary>
 	[JsonProperty("pinned", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Pinned { get; internal set; }
 
 	/// <summary>
 	/// Gets the id of the webhook that generated this message.
 	/// </summary>
 	[JsonProperty("webhook_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? WebhookId { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of the message.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageType? MessageType { get; internal set; }
 
 	/// <summary>
 	/// Gets the message activity in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("activity", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageActivity Activity { get; internal set; }
 
 	/// <summary>
 	/// Gets the message application in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("application", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageApplication Application { get; internal set; }
 
 	/// <summary>
 	/// Gets the message application id in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// Gets the internal reference.
 	/// </summary>
 	[JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
 	internal InternalDiscordMessageReference? InternalReference { get; set; }
 
 	/// <summary>
 	/// Gets the original message reference from the crossposted message.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMessageReference Reference
 		=> this.InternalReference.HasValue ? this?.InternalBuildMessageReference() : null;
 
 	/// <summary>
 	/// Gets the bitwise flags for this message.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageFlags? Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message originated from a webhook.
 	/// </summary>
 	[JsonIgnore]
 	public bool WebhookMessage
 		=> this.WebhookId != null;
 
 	/// <summary>
 	/// Gets the jump link to this message.
 	/// </summary>
 	[JsonIgnore]
 	public Uri JumpLink => this._jumpLink.Value;
 	private readonly Lazy<Uri> _jumpLink;
 
 	/// <summary>
 	/// Gets stickers for this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordSticker> Stickers
 		=> this._stickersLazy.Value;
 
 	[JsonProperty("sticker_items", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordSticker> StickersInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordSticker>> _stickersLazy;
 
 	/// <summary>
 	/// Gets the guild id.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets the message object for the referenced message
 	/// </summary>
 	[JsonProperty("referenced_message", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessage ReferencedMessage { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message is a response to an interaction.
 	/// </summary>
 	[JsonProperty("interaction", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageInteraction Interaction { get; internal set; }
 
 	/// <summary>
 	/// Gets the thread that was started from this message.
 	/// </summary>
 	[JsonProperty("thread", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannel Thread { get; internal set; }
 
 	/// <summary>
 	/// Build the message reference.
 	/// </summary>
 	internal DiscordMessageReference InternalBuildMessageReference()
 	{
 		var client = this.Discord as DiscordClient;
 		var guildId = this.InternalReference.Value.GuildId;
 		var channelId = this.InternalReference.Value.ChannelId;
 		var messageId = this.InternalReference.Value.MessageId;
 
 		var reference = new DiscordMessageReference();
 
 		if (guildId.HasValue)
 			reference.Guild = client.GuildsInternal.TryGetValue(guildId.Value, out var g)
 				? g
 				: new DiscordGuild
 				{
 					Id = guildId.Value,
 					Discord = client
 				};
 
 		var channel = client.InternalGetCachedChannel(channelId.Value);
 
 		if (channel == null)
 		{
 			reference.Channel = new DiscordChannel
 			{
 				Id = channelId.Value,
 				Discord = client
 			};
 
 			if (guildId.HasValue)
 				reference.Channel.GuildId = guildId.Value;
 		}
 
 		else reference.Channel = channel;
 
 		if (client.MessageCache != null && client.MessageCache.TryGet(m => m.Id == messageId.Value && m.ChannelId == channelId, out var msg))
 			reference.Message = msg;
 
 		else
 		{
 			reference.Message = new DiscordMessage
 			{
 				ChannelId = this.ChannelId,
 				Discord = client
 			};
 
 			if (messageId.HasValue)
 				reference.Message.Id = messageId.Value;
 		}
 
 		return reference;
 	}
 
 
 	/// <summary>
 	/// Gets the mentions.
 	/// </summary>
 	/// <returns>An array of IMentions.</returns>
 	private List<IMention> GetMentions()
 	{
 		var mentions = new List<IMention>();
 
 		if (this.ReferencedMessage != null && this.MentionedUsersInternal.Contains(this.ReferencedMessage.Author))
 			mentions.Add(new RepliedUserMention());
 
 		if (this.MentionedUsersInternal.Any())
 			mentions.AddRange(this.MentionedUsersInternal.Select(m => (IMention)new UserMention(m)));
 
 		if (this.MentionedRoleIds.Any())
 			mentions.AddRange(this.MentionedRoleIds.Select(r => (IMention)new RoleMention(r)));
 
 		return mentions;
 	}
 
 	/// <summary>
 	/// Populates the mentions.
 	/// </summary>
 	internal void PopulateMentions()
 	{
 		var guild = this.Channel?.Guild;
 		this.MentionedUsersInternal ??= new List<DiscordUser>();
 		this.MentionedRolesInternal ??= new List<DiscordRole>();
 		this.MentionedChannelsInternal ??= new List<DiscordChannel>();
 
 		var mentionedUsers = new HashSet<DiscordUser>(new DiscordUserComparer());
 		if (guild != null)
 		{
 			foreach (var usr in this.MentionedUsersInternal)
 			{
 				usr.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 
 				mentionedUsers.Add(guild.MembersInternal.TryGetValue(usr.Id, out var member) ? member : usr);
 			}
 		}
 		if (!string.IsNullOrWhiteSpace(this.Content))
 		{
 			//mentionedUsers.UnionWith(Utilities.GetUserMentions(this).Select(this.Discord.GetCachedOrEmptyUserInternal));
 			if (guild != null)
 			{
 				//this._mentionedRoles = this._mentionedRoles.Union(Utilities.GetRoleMentions(this).Select(xid => guild.GetRole(xid))).ToList();
 				this.MentionedRolesInternal = this.MentionedRolesInternal.Union(this.MentionedRoleIds.Select(xid => guild.GetRole(xid))).ToList();
 				this.MentionedChannelsInternal = this.MentionedChannelsInternal.Union(Utilities.GetChannelMentions(this).Select(xid => guild.GetChannel(xid))).ToList();
 			}
 		}
 
 		this.MentionedUsersInternal = mentionedUsers.ToList();
 	}
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifyAsync(Optional<string> content)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="embed">New embed.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifyAsync(Optional<DiscordEmbed> embed = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, embed.Map(v => new[] { v }).ValueOr(Array.Empty<DiscordEmbed>()), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embed">New embed.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifyAsync(Optional<string> content, Optional<DiscordEmbed> embed = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embed.Map(v => new[] { v }).ValueOr(Array.Empty<DiscordEmbed>()), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embeds">New embeds.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifyAsync(Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="builder">The builder of the message to edit.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifyAsync(DiscordMessageBuilder builder)
 	{
 		builder.Validate(true);
 		return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, Optional.Some(builder.Embeds.AsEnumerable()), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? Optional.Some(builder.Attachments.AsEnumerable()) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? Optional.Some(this.Attachments.AsEnumerable()) : Array.Empty<DiscordAttachment>() : null);
 	}
 
 	/// <summary>
 	/// Edits the message embed suppression.
 	/// </summary>
 	/// <param name="suppress">Suppress embeds.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifySuppressionAsync(bool suppress = false)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, default, default, suppress, default, default);
 
 	/// <summary>
 	/// Clears all attachments from the message.
 	/// </summary>
 	/// <returns></returns>
 	public Task<DiscordMessage> ClearAttachmentsAsync()
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, default, default, Array.Empty<DiscordAttachment>());
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="action">The builder of the message to edit.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> ModifyAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		builder.Validate(true);
 		return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, Optional.Some(builder.Embeds.AsEnumerable()), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? Optional.Some(builder.Attachments.AsEnumerable()) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? Optional.Some(this.Attachments.AsEnumerable()) : Array.Empty<DiscordAttachment>() : null);
 	}
 
 	/// <summary>
 	/// Deletes the message.
 	/// </summary>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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.DeleteMessageAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Creates a thread.
 	/// Depending on the <see cref="ChannelType"/> of the parent channel it's either a <see cref="ChannelType.PublicThread"/> or a <see cref="ChannelType.NewsThread"/>.
 	/// </summary>
 	/// <param name="name">The name of the thread.</param>
 	/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/></param>
 	/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 	/// <param name="reason">The reason.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> 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="NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified.</exception>
 	public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, int? rateLimitPerUser = null, string reason = null) =>
 		Utilities.CheckThreadAutoArchiveDurationFeature(this.Channel.Guild, autoArchiveDuration)
 			? await this.Discord.ApiClient.CreateThreadAsync(this.ChannelId, this.Id, name, autoArchiveDuration, this.Channel.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, isForum: false, reason: reason)
 			: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 	/// <summary>
 	/// Pins the message in its channel.
 	/// </summary>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 PinAsync()
 		=> this.Discord.ApiClient.PinMessageAsync(this.ChannelId, this.Id);
 
 	/// <summary>
 	/// Unpins the message in its channel.
 	/// </summary>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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 UnpinAsync()
 		=> this.Discord.ApiClient.UnpinMessageAsync(this.ChannelId, this.Id);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="content">Message content to respond with.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> RespondAsync(string content)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> RespondAsync(DiscordEmbed embed)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="content">Message content to respond with.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> RespondAsync(string content, DiscordEmbed embed)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="builder">The Discord message builder.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> RespondAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="action">The Discord message builder.</param>
 	/// <returns>The sent message.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member 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> RespondAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		return this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 	}
 
 	/// <summary>
 	/// Creates a reaction to this message.
 	/// </summary>
 	/// <param name="emoji">The emoji you want to react with, either an emoji or name:id</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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 CreateReactionAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.CreateReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Deletes your own reaction
 	/// </summary>
 	/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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 DeleteOwnReactionAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.DeleteOwnReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Deletes another user's reaction.
 	/// </summary>
 	/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id.</param>
 	/// <param name="user">Member you want to remove the reaction for</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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 DeleteReactionAsync(DiscordEmoji emoji, DiscordUser user, string reason = null)
 		=> this.Discord.ApiClient.DeleteUserReactionAsync(this.ChannelId, this.Id, user.Id, emoji.ToReactionString(), reason);
 
 	/// <summary>
 	/// Gets users that reacted with this emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to react with.</param>
 	/// <param name="limit">Limit of users to fetch.</param>
 	/// <param name="after">Fetch users after this user's id.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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<DiscordUser>> GetReactionsAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 		=> this.GetReactionsInternalAsync(emoji, limit, after);
 
 	/// <summary>
 	/// Deletes all reactions for this message.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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 DeleteAllReactionsAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteAllReactionsAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Deletes all reactions of a specific reaction for this message.
 	/// </summary>
 	/// <param name="emoji">The emoji to clear, either an emoji or name:id.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the emoji 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 DeleteReactionsEmojiAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.DeleteReactionsEmojiAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Gets the reactions.
 	/// </summary>
 	/// <param name="emoji">The emoji to search for.</param>
 	/// <param name="limit">The limit of results.</param>
 	/// <param name="after">Get the reasctions after snowflake.</param>
 	private async Task<IReadOnlyList<DiscordUser>> GetReactionsInternalAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 	{
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of reactions' users.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordUser>();
 
 		var users = new List<DiscordUser>(limit);
 		var remaining = limit;
 		var last = after;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetReactionsAsync(this.Channel.Id, this.Id, emoji.ToReactionString(), last, fetchSize).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			users.AddRange(fetch);
 			last = fetch.LastOrDefault()?.Id;
 		} while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordUser>(users);
 	}
 
 	/// <summary>
 	/// Returns a string representation of this message.
 	/// </summary>
 	/// <returns>String representation of this message.</returns>
 	public override string ToString()
 		=> $"Message {this.Id}; Attachment count: {this.AttachmentsInternal.Count}; Embed count: {this.EmbedsInternal.Count}; Contents: {this.Content}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMessage"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordMessage"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordMessage);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMessage"/> is equal to another <see cref="DiscordMessage"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordMessage"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordMessage"/> is equal to this <see cref="DiscordMessage"/>.</returns>
 	public bool Equals(DiscordMessage e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.ChannelId == e.ChannelId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordMessage"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordMessage"/>.</returns>
 	public override int GetHashCode()
 	{
 		var hash = 13;
 
 		hash = (hash * 7) + this.Id.GetHashCode();
 		hash = (hash * 7) + this.ChannelId.GetHashCode();
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMessage"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First message to compare.</param>
 	/// <param name="e2">Second message to compare.</param>
 	/// <returns>Whether the two messages are equal.</returns>
 	public static bool operator ==(DiscordMessage e1, DiscordMessage e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null)
 			&& (o1 == null || o2 != null)
 			&& ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.ChannelId == e2.ChannelId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMessage"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First message to compare.</param>
 	/// <param name="e2">Second message to compare.</param>
 	/// <returns>Whether the two messages are not equal.</returns>
 	public static bool operator !=(DiscordMessage e1, DiscordMessage e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
index 92c396e51..8de34e824 100644
--- a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
@@ -1,459 +1,459 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Constructs a Message to be sent.
 /// </summary>
 public sealed class DiscordMessageBuilder
 {
 	/// <summary>
 	/// Gets or Sets the Message to be sent.
 	/// </summary>
 	public string Content
 	{
 		get => this._content;
 		set
 		{
 			if (value != null && value.Length > 2000)
 				throw new ArgumentException("Content cannot exceed 2000 characters.", nameof(value));
 			this._content = value;
 		}
 	}
 	private string _content;
 
 	/// <summary>
 	/// Gets or sets the embed for the builder. This will always set the builder to have one embed.
 	/// </summary>
 	public DiscordEmbed Embed
 	{
 		get => this._embeds.Count > 0 ? this._embeds[0] : null;
 		set
 		{
 			this._embeds.Clear();
 			this._embeds.Add(value);
 		}
 	}
 
 	/// <summary>
 	/// Gets the Sticker to be send.
 	/// </summary>
 	public DiscordSticker Sticker { get; set; }
 
 	/// <summary>
 	/// Gets the Embeds to be sent.
 	/// </summary>
 	public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 	private readonly List<DiscordEmbed> _embeds = new();
 
 	/// <summary>
 	/// Gets or Sets if the message should be TTS.
 	/// </summary>
 	public bool IsTts { get; set; }
 
 	/// <summary>
 	/// Whether to keep previous attachments.
 	/// </summary>
 	internal bool? KeepAttachmentsInternal;
 
 	/// <summary>
 	/// Gets the Allowed Mentions for the message to be sent.
 	/// </summary>
 	public List<IMention> Mentions { get; private set; }
 
 	/// <summary>
 	/// Gets the Files to be sent in the Message.
 	/// </summary>
 	public IReadOnlyCollection<DiscordMessageFile> Files => this.FilesInternal;
 	internal readonly List<DiscordMessageFile> FilesInternal = new();
 
 	/// <summary>
 	/// Gets the components that will be attached to the message.
 	/// </summary>
 	public IReadOnlyList<DiscordActionRowComponent> Components => this.ComponentsInternal;
 	internal readonly List<DiscordActionRowComponent> ComponentsInternal = new(5);
 
 	/// <summary>
 	/// Gets the Attachments to be sent in the Message.
 	/// </summary>
 	public IReadOnlyList<DiscordAttachment> Attachments => this.AttachmentsInternal;
 	internal readonly List<DiscordAttachment> AttachmentsInternal = new();
 
 	/// <summary>
 	/// Gets the Reply Message ID.
 	/// </summary>
 	public ulong? ReplyId { get; private set; }
 
 	/// <summary>
 	/// Gets if the Reply should mention the user.
 	/// </summary>
 	public bool MentionOnReply { get; private set; }
 
 	/// <summary>
 	/// Gets if the embeds should be suppressed.
 	/// </summary>
 	public bool Suppressed { get; private set; }
 
 	/// <summary>
 	/// Gets if the Reply will error if the Reply Message Id does not reference a valid message.
 	/// <para>If set to false, invalid replies are send as a regular message.</para>
 	/// <para>Defaults to false.</para>
 	/// </summary>
 	public bool FailOnInvalidReply { get; set; }
 
 	/// <summary>
 	/// Sets the Content of the Message.
 	/// </summary>
 	/// <param name="content">The content to be set.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithContent(string content)
 	{
 		this.Content = content;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a sticker to the message. Sticker must be from current guild.
 	/// </summary>
 	/// <param name="sticker">The sticker to add.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithSticker(DiscordSticker sticker)
 	{
 		this.Sticker = sticker;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a row of components to a message, up to 5 components per row, and up to 5 rows per message.
 	/// </summary>
 	/// <param name="components">The components to add to the message.</param>
 	/// <returns>The current builder to be chained.</returns>
-	/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
+	/// <exception cref="ArgumentOutOfRangeException">No components were passed.</exception>
 	public DiscordMessageBuilder AddComponents(params DiscordComponent[] components)
 		=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
 	/// <summary>
 	/// Appends several rows of components to the message
 	/// </summary>
 	/// <param name="components">The rows of components to add, holding up to five each.</param>
 	/// <returns></returns>
 	public DiscordMessageBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 	{
 		var ara = components.ToArray();
 
 		if (ara.Length + this.ComponentsInternal.Count > 5)
 			throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 		foreach (var ar in ara)
 			this.ComponentsInternal.Add(ar);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a row of components to a message, up to 5 components per row, and up to 5 rows per message.
 	/// </summary>
 	/// <param name="components">The components to add to the message.</param>
 	/// <returns>The current builder to be chained.</returns>
-	/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
+	/// <exception cref="ArgumentOutOfRangeException">No components were passed.</exception>
 	public DiscordMessageBuilder AddComponents(IEnumerable<DiscordComponent> components)
 	{
 		var cmpArr = components.ToArray();
 		var count = cmpArr.Length;
 
 		if (!cmpArr.Any())
 			throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
 		if (count > 5)
 			throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 		var comp = new DiscordActionRowComponent(cmpArr);
 		this.ComponentsInternal.Add(comp);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message should be TTS.
 	/// </summary>
 	/// <param name="isTts">If TTS should be set.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder HasTts(bool isTts)
 	{
 		this.IsTts = isTts;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the embed for the current builder.
 	/// </summary>
 	/// <param name="embed">The embed that should be set.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithEmbed(DiscordEmbed embed)
 	{
 		if (embed == null)
 			return this;
 
 		this.Embed = embed;
 		return this;
 	}
 
 	/// <summary>
 	/// Appends an embed to the current builder.
 	/// </summary>
 	/// <param name="embed">The embed that should be appended.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder AddEmbed(DiscordEmbed embed)
 	{
 		if (embed == null)
 			return this; //Providing null embeds will produce a 400 response from Discord.//
 		this._embeds.Add(embed);
 		return this;
 	}
 
 	/// <summary>
 	/// Appends several embeds to the current builder.
 	/// </summary>
 	/// <param name="embeds">The embeds that should be appended.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 	{
 		this._embeds.AddRange(embeds);
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has allowed mentions.
 	/// </summary>
 	/// <param name="allowedMention">The allowed Mention that should be sent.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithAllowedMention(IMention allowedMention)
 	{
 		if (this.Mentions != null)
 			this.Mentions.Add(allowedMention);
 		else
 			this.Mentions = new List<IMention> { allowedMention };
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has allowed mentions.
 	/// </summary>
 	/// <param name="allowedMentions">The allowed Mentions that should be sent.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithAllowedMentions(IEnumerable<IMention> allowedMentions)
 	{
 		if (this.Mentions != null)
 			this.Mentions.AddRange(allowedMentions);
 		else
 			this.Mentions = allowedMentions.ToList();
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="fileName">The fileName that the file should be sent as.</param>
 	/// <param name="stream">The Stream to the file.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithFile(string fileName, Stream stream, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this.FilesInternal.Any(x => x.FileName == fileName))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this.FilesInternal.Add(new DiscordMessageFile(fileName, stream, stream.Position, description: description));
 		else
 			this.FilesInternal.Add(new DiscordMessageFile(fileName, stream, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="stream">The Stream to the file.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this.FilesInternal.Any(x => x.FileName == stream.Name))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this.FilesInternal.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 		else
 			this.FilesInternal.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="files">The Files that should be sent.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 	{
 		if (this.Files.Count + files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		foreach (var file in files)
 		{
 			if (this.FilesInternal.Any(x => x.FileName == file.Key))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this.FilesInternal.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 			else
 				this.FilesInternal.Add(new DiscordMessageFile(file.Key, file.Value, null));
 		}
 
 		return this;
 	}
 
 	/// <summary>
 	/// Modifies the given attachments on edit.
 	/// </summary>
 	/// <param name="attachments">Attachments to edit.</param>
 	/// <returns></returns>
 	public DiscordMessageBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
 	{
 		this.AttachmentsInternal.AddRange(attachments);
 		return this;
 	}
 
 	/// <summary>
 	/// Whether to keep the message attachments, if new ones are added.
 	/// </summary>
 	/// <returns></returns>
 	public DiscordMessageBuilder KeepAttachments(bool keep)
 	{
 		this.KeepAttachmentsInternal = keep;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message is a reply
 	/// </summary>
 	/// <param name="messageId">The ID of the message to reply to.</param>
 	/// <param name="mention">If we should mention the user in the reply.</param>
 	/// <param name="failOnInvalidReply">Whether sending a reply that references an invalid message should be </param>
 	/// <returns>The current builder to be chained.</returns>
 	public DiscordMessageBuilder WithReply(ulong messageId, bool mention = false, bool failOnInvalidReply = false)
 	{
 		this.ReplyId = messageId;
 		this.MentionOnReply = mention;
 		this.FailOnInvalidReply = failOnInvalidReply;
 
 		if (mention)
 		{
 			this.Mentions ??= new List<IMention>();
 			this.Mentions.Add(new RepliedUserMention());
 		}
 
 		return this;
 	}
 
 
 	/// <summary>
 	/// Sends the Message to a specific channel
 	/// </summary>
 	/// <param name="channel">The channel the message should be sent to.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public Task<DiscordMessage> SendAsync(DiscordChannel channel) => channel.SendMessageAsync(this);
 
 	/// <summary>
 	/// Sends the modified message.
 	/// <para>Note: Message replies cannot be modified. To clear the reply, simply pass <see langword="null"/> to <see cref="WithReply"/>.</para>
 	/// </summary>
 	/// <param name="msg">The original Message to modify.</param>
 	/// <returns>The current builder to be chained.</returns>
 	public Task<DiscordMessage> ModifyAsync(DiscordMessage msg) => msg.ModifyAsync(this);
 
 	/// <summary>
 	/// Clears all message components on this builder.
 	/// </summary>
 	public void ClearComponents()
 		=> this.ComponentsInternal.Clear();
 
 	/// <summary>
 	/// Allows for clearing the Message Builder so that it can be used again to send a new message.
 	/// </summary>
 	public void Clear()
 	{
 		this.Content = "";
 		this._embeds.Clear();
 		this.IsTts = false;
 		this.Mentions = null;
 		this.FilesInternal.Clear();
 		this.ReplyId = null;
 		this.MentionOnReply = false;
 		this.ComponentsInternal.Clear();
 		this.Suppressed = false;
 		this.Sticker = null;
 		this.AttachmentsInternal.Clear();
 		this.KeepAttachmentsInternal = false;
 	}
 
 	/// <summary>
 	/// Does the validation before we send a the Create/Modify request.
 	/// </summary>
 	/// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
 	internal void Validate(bool isModify = false)
 	{
 		if (this._embeds.Count > 10)
 			throw new ArgumentException("A message can only have up to 10 embeds.");
 
 		if (!isModify)
 		{
 			if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && (!this.Embeds?.Any() ?? true) && this.Sticker is null && (!this.Embeds?.Any() ?? true))
 				throw new ArgumentException("You must specify content, an embed, a sticker, a component or at least one file.");
 
 			if (this.Components.Count > 5)
 				throw new InvalidOperationException("You can only have 5 action rows per message.");
 
 			if (this.Components.Any(c => c.Components.Count > 5))
 				throw new InvalidOperationException("Action rows can only have 5 components");
 		}
 	}
 }
diff --git a/DisCatSharp/Entities/Optional.cs b/DisCatSharp/Entities/Optional.cs
index 3ec352227..2809e2d8f 100644
--- a/DisCatSharp/Entities/Optional.cs
+++ b/DisCatSharp/Entities/Optional.cs
@@ -1,400 +1,400 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Linq;
 using System.Reflection;
 
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Helper methods for instantiating an <see cref="Optional{T}"/>.
 /// </summary>
 /// <remarks>
 /// This class only serves to provide <see cref="Some{T}"/> and <see cref="None"/>
 /// as utility that supports type inference.
 /// </remarks>
 public static class Optional
 {
 	/// <summary>
 	/// Provided for easy creation of empty <see cref="Optional{T}"/>s.
 	/// </summary>
 	public static readonly None None = new();
 
 	/// <summary>
 	/// Creates a new <see cref="Optional{T}"/> with specified value and valid state.
 	/// </summary>
 	/// <param name="value">Value to populate the optional with.</param>
 	/// <typeparam name="T">Type of the value.</typeparam>
 	/// <returns>Created optional.</returns>
 	public static Optional<T> Some<T>(T value)
 		=> value;
 
 	/// <summary>
-	/// 
+	///
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	/// <param name="value"></param>
 	/// <returns></returns>
 	public static Optional<T> FromNullable<T>(T value)
 		=> value == null
 			? None
 			: value;
 
 	/// <summary>
 	/// Creates a new <see cref="Optional{T}"/> with specified value and valid state.
 	/// </summary>
 	/// <param name="value">Value to populate the optional with.</param>
 	/// <typeparam name="T">Type of the value.</typeparam>
 	/// <returns>Created optional.</returns>
 	[Obsolete("Renamed to Some.")]
 	public static Optional<T> FromValue<T>(T value)
 		=> value;
 
 	/// <summary>
 	/// Creates a new empty <see cref="Optional{T}"/> with no value and invalid state.
 	/// </summary>
 	/// <typeparam name="T">The type that the created instance is wrapping around.</typeparam>
 	/// <returns>Created optional.</returns>
 	[Obsolete("Use None.")]
 	public static Optional<T> FromNoValue<T>()
 		=> default;
 }
 
 /// <summary>
 /// Unit type for creating an empty <see cref="Optional{T}"/>s.
 /// </summary>
 public struct None
 { }
 
 /// <summary>
 /// Used internally to make serialization more convenient, do NOT change this, do NOT implement this yourself.
 /// </summary>
 internal interface IOptional
 {
 	/// <summary>
 	/// Gets a whether it has a value.
 	/// </summary>
 	bool HasValue { get; }
 
 	/// <summary>
 	/// Gets the raw value.
 	/// </summary>
 	/// <remarks>
 	/// Must NOT throw InvalidOperationException.
 	/// </remarks>
 	object RawValue { get; }
 }
 
 /// <summary>
 /// Represents a wrapper which may or may not have a value.
 /// </summary>
 /// <typeparam name="T">Type of the value.</typeparam>
 [JsonConverter(typeof(OptionalJsonConverter))]
 public readonly struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IOptional
 {
 	/// <summary>
 	/// Static empty <see cref="Optional"/>.
 	/// </summary>
 	public static readonly Optional<T> None = default;
 
 	/// <summary>
 	/// Gets whether this <see cref="Optional{T}"/> has a value.
 	/// </summary>
 	public bool HasValue { get; }
 
 	/// <summary>
 	/// Gets the value of this <see cref="Optional{T}"/>.
 	/// </summary>
-	/// <exception cref="System.InvalidOperationException">If this <see cref="Optional{T}"/> has no value.</exception>
+	/// <exception cref="InvalidOperationException">If this <see cref="Optional{T}"/> has no value.</exception>
 	public T Value => this.HasValue ? this._val : throw new InvalidOperationException("Value is not set.");
 
 	/// <summary>
 	/// Gets the raw value.
 	/// </summary>
 	object IOptional.RawValue => this._val;
 
 	private readonly T _val;
 
 	/// <summary>
 	/// Creates a new <see cref="Optional{T}"/> with specified value.
 	/// </summary>
 	/// <param name="value">Value of this option.</param>
 	[Obsolete("Use Optional.Some")]
 	public Optional(T value)
 	{
 		this._val = value;
 		this.HasValue = true;
 	}
 
 	[Obsolete("Renamed to Map")]
 	public Optional<TOut> IfPresent<TOut>(Func<T, TOut> mapper)
 		=> this.Map(mapper);
 
 	/// <summary>
 	/// Performs a mapping operation on the current <see cref="Optional{T}"/>, turning it into an Optional holding a
 	/// <typeparamref name="TOut"/> instance if the source optional contains a value; otherwise, returns an
 	/// <see cref="Optional{T}"/> of that same type with no value.
 	/// </summary>
 	/// <param name="mapper">The mapping function to apply on the current value if it exists</param>
 	/// <typeparam name="TOut">The type of the target value returned by <paramref name="mapper"/></typeparam>
 	/// <returns>
 	/// An <see cref="Optional{T}"/> containing a value denoted by calling <paramref name="mapper"/> if the current
 	/// <see cref="Optional{T}"/> contains a value; otherwise, an empty <see cref="Optional{T}"/> of the target
 	/// type.
 	/// </returns>
 	public Optional<TOut> Map<TOut>(Func<T, TOut> mapper)
 		=> this.HasValue
 			? mapper(this._val)
 			: Optional.None;
 
 	/// <summary>
 	/// Maps to <see cref="None"/> for <see cref="None"/>, to <code>default</code> for <code>null</code> and to the mapped value otherwise./>
 	/// </summary>
 	/// <typeparam name="TOut">The type to map to.</typeparam>
 	/// <param name="mapper">The function that does the mapping of the non-null <typeparamref name="T"/>.</param>
 	/// <returns>The mapped value.</returns>
 	public Optional<TOut> MapOrNull<TOut>(Func<T, TOut> mapper)
 		=> this.HasValue
 			? this._val == null
 				? default
 				: mapper(this._val)
 			: Optional.None;
 
 	/// <summary>
 	/// Gets the value of the <see cref="Optional{T}"/> or a specified value, if the <see cref="Optional{T}"/> has no value.
 	/// </summary>
 	/// <param name="other">The value to return if this has no value.</param>
 	/// <returns>Either the value of the <see cref="Optional{T}"/> if present or the provided value.</returns>
 	public T ValueOr(T other)
 		=> this.HasValue
 			? this._val
 			: other;
 
 	/// <summary>
 	/// Gets the value of the <see cref="Optional{T}"/> or the default value for <typeparamref name="T"/>, if the
 	/// <see cref="Optional{T}"/> has no value.
 	/// </summary>
 	/// <returns>Either the value of the <see cref="Optional{T}"/> if present or the type's default value.</returns>
 	public T ValueOrDefault()
 		=> this.ValueOr(default);
 
 	/// <summary>
 	/// Gets the <see cref="Optional"/>'s value, or throws the provided exception if it's empty.
 	/// </summary>
 	/// <param name="err">The exception to throw if the optional is empty.</param>
 	/// <returns>The value of the <see cref="Optional"/>, if present.</returns>
 	public T Expect(Exception err)
 		=> !this.HasValue ? throw err : this._val;
 
 	/// <summary>
 	/// Gets the <see cref="Optional"/>'s value, or throws a standard exception with the provided string if it's
 	/// empty.
 	/// </summary>
 	/// <param name="str">The string provided to the exception.</param>
 	/// <returns>The value of the <see cref="Optional"/>, if present.</returns>
 	public T Expect(string str) => this.Expect(new InvalidOperationException(str));
 
 	/// <summary>
 	/// Checks if this has a value and tests the predicate if it does.
 	/// </summary>
 	/// <param name="predicate">The predicate to test if this has a value.</param>
 	/// <returns>True if this has a value and the predicate is fulfilled, false otherwise.</returns>
 	public bool HasValueAnd(Predicate<T> predicate)
 		=> this.HasValue && predicate(this._val);
 
 	/// <summary>
 	/// Returns a string representation of this optional value.
 	/// </summary>
 	/// <returns>String representation of this optional value.</returns>
 	public override string ToString() => $"Optional<{typeof(T)}> ({this.Map(x => x.ToString()).ValueOr("<no value>")})";
 
 	/// <summary>
 	/// Checks whether this <see cref="Optional{T}"/> (or its value) are equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="Optional{T}"/> or its value.</returns>
 	public override bool Equals(object obj) =>
 		obj switch
 		{
 			T t => this.Equals(t),
 			Optional<T> opt => this.Equals(opt),
 			_ => false,
 		};
 
 	/// <summary>
 	/// Checks whether this <see cref="Optional{T}"/> is equal to another <see cref="Optional{T}"/>.
 	/// </summary>
 	/// <param name="e"><see cref="Optional{T}"/> to compare to.</param>
 	/// <returns>Whether the <see cref="Optional{T}"/> is equal to this <see cref="Optional{T}"/>.</returns>
 	public bool Equals(Optional<T> e) => (!this.HasValue && !e.HasValue) || (this.HasValue == e.HasValue && this.Value.Equals(e.Value));
 
 	/// <summary>
 	/// Checks whether the value of this <see cref="Optional{T}"/> is equal to specified object.
 	/// </summary>
 	/// <param name="e">Object to compare to.</param>
 	/// <returns>Whether the object is equal to the value of this <see cref="Optional{T}"/>.</returns>
 	public bool Equals(T e)
 		=> this.HasValue && ReferenceEquals(this.Value, e);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="Optional{T}"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="Optional{T}"/>.</returns>
 	public override int GetHashCode()
 		=> this.Map(x => x.GetHashCode()).ValueOrDefault();
 
 	public static implicit operator Optional<T>(T val)
 #pragma warning disable 0618
 		=> new(val);
 #pragma warning restore 0618
 
 	public static explicit operator T(Optional<T> opt)
 		=> opt.Value;
 
 	/// <summary>
 	/// Creates an empty optional.
 	/// </summary>
 	public static implicit operator Optional<T>(None _) => default;
 
 	public static bool operator ==(Optional<T> opt1, Optional<T> opt2)
 		=> opt1.Equals(opt2);
 
 	public static bool operator !=(Optional<T> opt1, Optional<T> opt2)
 		=> !opt1.Equals(opt2);
 
 	public static bool operator ==(Optional<T> opt, T t)
 		=> opt.Equals(t);
 
 	public static bool operator !=(Optional<T> opt, T t)
 		=> !opt.Equals(t);
 }
 
 /// <summary>
 /// Represents an optional json contract resolver.
 /// <seealso cref="DiscordJson.s_serializer"/>
 /// </summary>
 internal sealed class OptionalJsonContractResolver : DefaultContractResolver
 {
 	/// <summary>
 	/// Creates the property.
 	/// </summary>
 	/// <param name="member">The member.</param>
 	/// <param name="memberSerialization">The member serialization.</param>
 	protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
 	{
 		var property = base.CreateProperty(member, memberSerialization);
 
 		var type = property.PropertyType;
 
 		if (!type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IOptional)))
 			return property;
 
 		// we cache the PropertyInfo object here (it's captured in closure). we don't have direct
 		// access to the property value so we have to reflect into it from the parent instance
 		// we use UnderlyingName instead of PropertyName in case the C# name is different from the Json name.
 		var declaringMember = property.DeclaringType.GetTypeInfo().DeclaredMembers
 			.FirstOrDefault(e => e.Name == property.UnderlyingName);
 
 		switch (declaringMember)
 		{
 			case PropertyInfo declaringProp:
 				property.ShouldSerialize = instance => // instance here is the declaring (parent) type
 				{
 					var optionalValue = declaringProp.GetValue(instance);
 					return (optionalValue as IOptional).HasValue;
 				};
 				return property;
 			case FieldInfo declaringField:
 				property.ShouldSerialize = instance => // instance here is the declaring (parent) type
 				{
 					var optionalValue = declaringField.GetValue(instance);
 					return (optionalValue as IOptional).HasValue;
 				};
 				return property;
 			default:
 				throw new InvalidOperationException(
 					"Can only serialize Optional<T> members that are fields or properties");
 		}
 	}
 }
 
 /// <summary>
 /// Represents an optional json converter.
 /// </summary>
 internal sealed class OptionalJsonConverter : JsonConverter
 {
 	/// <summary>
 	/// Writes the json.
 	/// </summary>
 	/// <param name="writer">The writer.</param>
 	/// <param name="value">The value.</param>
 	/// <param name="serializer">The serializer.</param>
 	public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 	{
 		// we don't check for HasValue here since it's checked in OptionalJsonContractResolver
 		var val = (value as IOptional).RawValue;
 		// JToken.FromObject will throw if `null` so we manually write a null value.
 		if (val == null)
 		{
 			// you can read serializer.NullValueHandling here, but unfortunately you can **not** skip serialization
 			// here, or else you will get a nasty JsonWriterException, so we just ignore its value and manually
 			// write the null.
 			writer.WriteToken(JsonToken.Null);
 		}
 		else
 		{
 			// convert the value to a JSON object and write it to the property value.
 			JToken.FromObject(val).WriteTo(writer);
 		}
 	}
 
 	/// <summary>
 	/// Reads the json.
 	/// </summary>
 	/// <param name="reader">The reader.</param>
 	/// <param name="objectType">The object type.</param>
 	/// <param name="existingValue">The existing value.</param>
 	/// <param name="serializer">The serializer.</param>
 	public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
 		JsonSerializer serializer)
 	{
 		var genericType = objectType.GenericTypeArguments[0];
 
 		var constructor = objectType.GetTypeInfo().DeclaredConstructors
 			.FirstOrDefault(e => e.GetParameters()[0].ParameterType == genericType);
 
 		return constructor.Invoke(new[] { serializer.Deserialize(reader, genericType) });
 	}
 
 	/// <summary>
 	/// Whether it can convert.
 	/// </summary>
 	/// <param name="objectType">The object type.</param>
 	public override bool CanConvert(Type objectType) => objectType.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IOptional));
 }
diff --git a/DisCatSharp/Entities/Sticker/DiscordSticker.cs b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
index a01fae220..6fe2dab97 100644
--- a/DisCatSharp/Entities/Sticker/DiscordSticker.cs
+++ b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
@@ -1,233 +1,233 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord Sticker.
 /// </summary>
 public class DiscordSticker : SnowflakeObject, IEquatable<DiscordSticker>
 {
 	/// <summary>
 	/// Gets the Pack ID of this sticker.
 	/// </summary>
 	[JsonProperty("pack_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? PackId { get; internal set; }
 
 	/// <summary>
 	/// Gets the Name of the sticker.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the Description of the sticker.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 	public string Description { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of sticker.
 	/// </summary>
 	[JsonProperty("type")]
 	public StickerType Type { get; internal set; }
 
 	/// <summary>
 	/// For guild stickers, gets the user that made the sticker.
 	/// </summary>
 	[JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild associated with this sticker, if any.
 	/// </summary>
 	public DiscordGuild Guild => (this.Discord as DiscordClient).InternalGetCachedGuild(this.GuildId);
 
 	/// <summary>
 	/// Gets the guild id the sticker belongs too.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this sticker is available. Only applicable to guild stickers.
 	/// </summary>
 	[JsonProperty("available", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Available { get; internal set; }
 
 	/// <summary>
 	/// Gets the sticker's sort order, if it's in a pack.
 	/// </summary>
 	[JsonProperty("sort_value", NullValueHandling = NullValueHandling.Ignore)]
 	public int? SortValue { get; internal set; }
 
 	/// <summary>
 	/// Gets the list of tags for the sticker.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<string> Tags
 		=> this.InternalTags != null ? this.InternalTags.Split(',') : Array.Empty<string>();
 
 	/// <summary>
 	/// Gets the asset hash of the sticker.
 	/// </summary>
 	[JsonProperty("asset", NullValueHandling = NullValueHandling.Ignore)]
 	public string Asset { get; internal set; }
 
 	/// <summary>
 	/// Gets the preview asset hash of the sticker.
 	/// </summary>
 	[JsonProperty("preview_asset", NullValueHandling = NullValueHandling.Ignore)]
 	public string PreviewAsset { get; internal set; }
 
 	/// <summary>
 	/// Gets the Format type of the sticker.
 	/// </summary>
 	[JsonProperty("format_type")]
 	public StickerFormat FormatType { get; internal set; }
 
 	/// <summary>
 	/// Gets the tags of the sticker.
 	/// </summary>
 	[JsonProperty("tags", NullValueHandling = NullValueHandling.Ignore)]
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 	internal string InternalTags { get; set; }
 
 	/// <summary>
 	/// Gets the url of the sticker.
 	/// </summary>
 	[JsonIgnore]
 	public string Url => $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.STICKERS}/{this.Id}.{(this.FormatType == StickerFormat.Lottie ? "json" : "png")}";
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordSticker"/> class.
 	/// </summary>
 	internal DiscordSticker()
 	{ }
 
 	/// <summary>
 	/// Gets the hash code of the current sticker.
 	/// </summary>
 	/// <returns>The hash code.</returns>
 	public override int GetHashCode()
 		=> this.PackId != null ? HashCode.Combine(this.Id.GetHashCode(), this.PackId.GetHashCode()) : HashCode.Combine(this.Id.GetHashCode(), this.GuildId.GetHashCode());
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordSticker"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordSticker"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as ForumPostTag);
 
 	/// <summary>
 	/// Whether to stickers are equal.
 	/// </summary>
 	/// <param name="other">DiscordSticker</param>
 	public bool Equals(DiscordSticker other)
 		=> this.Id == other.Id;
 
 	/// <summary>
 	/// Gets the sticker in readable format.
 	/// </summary>
 	public override string ToString() => $"Sticker {this.Id}; {this.Name}; {this.FormatType}";
 
 	/// <summary>
 	/// Modifies the sticker
 	/// </summary>
 	/// <param name="name">The name of the sticker</param>
 	/// <param name="description">The description of the sticker</param>
 	/// <param name="tags">The name of a unicode emoji representing the sticker's expression</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <returns>A sticker object</returns>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task<DiscordSticker> ModifyAsync(Optional<string> name, Optional<string> description, Optional<string> tags, string reason = null) =>
 		!this.GuildId.HasValue
 			? throw new ArgumentException("This sticker does not belong to a guild.")
 			: name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30)
 				? throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.")
 				: description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100)
 					? throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.")
 					: tags.HasValue && !DiscordEmoji.TryFromUnicode(this.Discord, tags.Value, out var emoji)
 						? throw new ArgumentException("Sticker tags needs to be a unicode emoji.")
 						: this.Discord.ApiClient.ModifyGuildStickerAsync(this.GuildId.Value, this.Id, name, description, tags, reason);
 
 	/// <summary>
 	/// Deletes the sticker
 	/// </summary>
 	/// <param name="reason">Audit log reason</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.GuildId.HasValue ? this.Discord.ApiClient.DeleteGuildStickerAsync(this.GuildId.Value, this.Id, reason) : throw new ArgumentException("The requested sticker is no guild sticker.");
 }
 
 /// <summary>
 /// The sticker type
 /// </summary>
 public enum StickerType : long
 {
 	/// <summary>
 	/// Standard nitro sticker
 	/// </summary>
 	Standard = 1,
 
 	/// <summary>
 	/// Custom guild sticker
 	/// </summary>
 	Guild = 2
 }
 
 /// <summary>
 /// The sticker type
 /// </summary>
 public enum StickerFormat : long
 {
 	/// <summary>
 	/// Sticker is a png
 	/// </summary>
 	Png = 1,
 
 	/// <summary>
 	/// Sticker is a animated png
 	/// </summary>
 	Apng = 2,
 
 	/// <summary>
 	/// Sticker is lottie
 	/// </summary>
 	Lottie = 3
 }
diff --git a/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs
index df09831fb..04267d221 100644
--- a/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs
@@ -1,342 +1,342 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord thread channel.
 /// </summary>
 public class DiscordThreadChannel : DiscordChannel
 {
 	/// <summary>
 	/// Gets ID of the owner that started this thread.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong OwnerId { get; internal set; }
 
 	[JsonProperty("total_message_sent", DefaultValueHandling = DefaultValueHandling.Ignore)]
 	public int TotalMessagesSent { get; internal set; }
 
 	/// <summary>
 	/// Gets an approximate count of messages in a thread, stops counting at 50.
 	/// </summary>
 	[JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MessageCount { get; internal set; }
 
 	/// <summary>
 	/// Gets an approximate count of users in a thread, stops counting at 50.
 	/// </summary>
 	[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MemberCount { get; internal set; }
 
 	/// <summary>
 	/// Represents the current member for this thread. This will have a value if the user has joined the thread.
 	/// </summary>
 	[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannelMember CurrentMember { get; internal set; }
 
 	/// <summary>
 	/// Gets the threads metadata.
 	/// </summary>
 	[JsonProperty("thread_metadata", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannelMetadata ThreadMetadata { get; internal set; }
 
 	/// <summary>
 	/// Gets the thread members object.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordThreadChannelMember> ThreadMembers => new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannelMember>(this.ThreadMembersInternal);
 
 	[JsonProperty("thread_member", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordThreadChannelMember> ThreadMembersInternal;
 
 	/// <summary>
 	/// List of applied tag ids.
 	/// </summary>
 	[JsonIgnore]
 	internal IReadOnlyList<ulong> AppliedTagIds
 		=> this.AppliedTagIdsInternal;
 
 	/// <summary>
 	/// List of applied tag ids.
 	/// </summary>
 	[JsonProperty("applied_tags", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<ulong> AppliedTagIdsInternal;
 
 	/// <summary>
 	/// Gets the list of applied tags.
 	/// Only applicable for forum channel posts.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<ForumPostTag> AppliedTags
 	  => this.AppliedTagIds?.Select(id => this.Parent.GetForumPostTag(id)).Where(x => x != null);
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
 	/// </summary>
 	internal DiscordThreadChannel()
 	{ }
 
 	#region Methods
 
 	/// <summary>
 	/// Modifies the current thread.
 	/// </summary>
 	/// <param name="action">Action to perform on this thread</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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="NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>.</exception>
 	public Task ModifyAsync(Action<ThreadEditModel> action)
 	{
 		var mdl = new ThreadEditModel();
 		action(mdl);
 
 		var canContinue = !mdl.AutoArchiveDuration.HasValue || !mdl.AutoArchiveDuration.Value.HasValue || Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.AutoArchiveDuration.Value.Value);
 		if (mdl.Invitable.HasValue)
 		{
 			canContinue = this.Guild.Features.CanCreatePrivateThreads;
 		}
 		return canContinue ? this.Discord.ApiClient.ModifyThreadAsync(this.Id, this.Parent.Type, mdl.Name, mdl.Locked, mdl.Archived, mdl.PerUserRateLimit, mdl.AutoArchiveDuration, mdl.Invitable, mdl.AppliedTags, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(mdl.AutoArchiveDuration.Value.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 	}
 
 	/// <summary>
 	/// Add a tag to the current thread.
 	/// </summary>
 	/// <param name="tag">The tag to add.</param>
 	/// <param name="reason">The reason for the audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 AddTagAsync(ForumPostTag tag, string reason = null)
 		=> await this.Discord.ApiClient.ModifyThreadAsync(this.Id, this.Parent.Type, null, null, null, null, null, null, new List<ForumPostTag>(this.AppliedTags) { tag }, reason: reason);
 
 	/// <summary>
 	/// Remove a tag from the current thread.
 	/// </summary>
 	/// <param name="tag">The tag to remove.</param>
 	/// <param name="reason">The reason for the audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 RemoveTagAsync(ForumPostTag tag, string reason = null)
 		=> await this.Discord.ApiClient.ModifyThreadAsync(this.Id, this.Parent.Type, null, null, null, null, null, null, new List<ForumPostTag>(this.AppliedTags).Where(x => x != tag).ToList(), reason: reason);
 
 	/// <summary>
 	/// Archives a thread.
 	/// </summary>
 	/// <param name="locked">Whether the thread should be locked.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 ArchiveAsync(bool locked = true, string reason = null)
 		=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, this.Parent.Type, null, locked, true, null, null, null, null, reason: reason);
 
 	/// <summary>
 	/// Unarchives a thread.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 UnarchiveAsync(string reason = null)
 		=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, this.Parent.Type, null, null, false, null, null, null, null, reason: reason);
 
 	/// <summary>
 	/// Gets the members of a thread. Needs the <see cref="DiscordIntents.GuildMembers"/> intent.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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<IReadOnlyList<DiscordThreadChannelMember>> GetMembersAsync()
 		=> await this.Discord.ApiClient.GetThreadMembersAsync(this.Id);
 
 	/// <summary>
 	/// Adds a member to this thread.
 	/// </summary>
 	/// <param name="memberId">The member id to be added.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 AddMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.AddThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Adds a member to this thread.
 	/// </summary>
 	/// <param name="member">The member to be added.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 AddMemberAsync(DiscordMember member)
 		=> this.AddMemberAsync(member.Id);
 
 	/// <summary>
 	/// Gets a member in this thread.
 	/// </summary>
 	/// <param name="memberId">The member to be added.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member is not part of the thread.</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<DiscordThreadChannelMember> GetMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Gets a member in this thread.
 	/// </summary>
 	/// <param name="member">The member to be added.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the member is not part of the thread.</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<DiscordThreadChannelMember> GetMemberAsync(DiscordMember member)
 		=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member.Id);
 
 	/// <summary>
 	/// Removes a member from this thread.
 	/// </summary>
 	/// <param name="memberId">The member id to be removed.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 RemoveMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Removes a member from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="member">The member to be removed.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 RemoveMemberAsync(DiscordMember member)
 		=> this.RemoveMemberAsync(member.Id);
 
 	/// <summary>
 	/// Adds a role to this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="roleId">The role id to be added.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 AddRoleAsync(ulong roleId)
 	{
 		var role = this.Guild.GetRole(roleId);
 		var members = await this.Guild.GetAllMembersAsync();
 		var roleMembers = members.Where(m => m.Roles.Contains(role));
 		foreach (var member in roleMembers)
 		{
 			await this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member.Id);
 		}
 	}
 
 	/// <summary>
 	/// Adds a role to this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="role">The role to be added.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 AddRoleAsync(DiscordRole role)
 		=> this.AddRoleAsync(role.Id);
 
 	/// <summary>
 	/// Removes a role from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="roleId">The role id to be removed.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 RemoveRoleAsync(ulong roleId)
 	{
 		var role = this.Guild.GetRole(roleId);
 		var members = await this.Guild.GetAllMembersAsync();
 		var roleMembers = members.Where(m => m.Roles.Contains(role));
 		foreach (var member in roleMembers)
 		{
 			await this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member.Id);
 		}
 	}
 
 	/// <summary>
 	/// Removes a role from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="role">The role to be removed.</param>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 RemoveRoleAsync(DiscordRole role)
 		=> this.RemoveRoleAsync(role.Id);
 
 	/// <summary>
 	/// Joins a thread.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client has no access to this thread.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 JoinAsync()
 		=> this.Discord.ApiClient.JoinThreadAsync(this.Id);
 
 	/// <summary>
 	/// Leaves a thread.
 	/// </summary>
-	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client has no access to this thread.</exception>
+	/// <exception cref="NotFoundException">Thrown when the thread 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 LeaveAsync()
 		=> this.Discord.ApiClient.LeaveThreadAsync(this.Id);
 
 	/// <summary>
 	/// Returns a string representation of this thread.
 	/// </summary>
 	/// <returns>String representation of this thread.</returns>
 	public override string ToString()
 		=> this.Type switch
 		{
 			ChannelType.NewsThread => $"News thread {this.Name} ({this.Id})",
 			ChannelType.PublicThread => $"Thread {this.Name} ({this.Id})",
 			ChannelType.PrivateThread => $"Private thread {this.Name} ({this.Id})",
 			_ => $"Thread {this.Name} ({this.Id})",
 		};
 	#endregion
 }
diff --git a/DisCatSharp/Entities/User/DiscordUser.cs b/DisCatSharp/Entities/User/DiscordUser.cs
index 3fe53f558..016ce164e 100644
--- a/DisCatSharp/Entities/User/DiscordUser.cs
+++ b/DisCatSharp/Entities/User/DiscordUser.cs
@@ -1,493 +1,493 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord user.
 /// </summary>
 public class DiscordUser : SnowflakeObject, IEquatable<DiscordUser>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 	/// </summary>
 	internal DiscordUser()
 	{ }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 	/// </summary>
 	/// <param name="transport">The transport user.</param>
 	internal DiscordUser(TransportUser transport)
 	{
 		this.Id = transport.Id;
 		this.Username = transport.Username;
 		this.Discriminator = transport.Discriminator;
 		this.AvatarHash = transport.AvatarHash;
 		this.AvatarDecorationHash = transport.AvatarDecorationHash;
 		this.BannerHash = transport.BannerHash;
 		this.BannerColorInternal = transport.BannerColor;
 		this.ThemeColorsInternal = (transport.ThemeColors ?? Array.Empty<int>()).ToList();
 		this.IsBot = transport.IsBot;
 		this.MfaEnabled = transport.MfaEnabled;
 		this.Verified = transport.Verified;
 		this.Email = transport.Email;
 		this.PremiumType = transport.PremiumType;
 		this.Locale = transport.Locale;
 		this.Flags = transport.Flags;
 		this.OAuthFlags = transport.OAuthFlags;
 		this.Bio = transport.Bio;
 		this.Pronouns = transport.Pronouns;
 	}
 
 	/// <summary>
 	/// Gets this user's username.
 	/// </summary>
 	[JsonProperty("username", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Username { get; internal set; }
 
 	/// <summary>
 	/// Gets this user's username with the discriminator.
 	/// Example: Discord#0000
 	/// </summary>
 	[JsonIgnore]
 	public virtual string UsernameWithDiscriminator
 		=> $"{this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Gets the user's 4-digit discriminator.
 	/// </summary>
 	[JsonProperty("discriminator", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Discriminator { get; internal set; }
 
 	/// <summary>
 	/// Gets the discriminator integer.
 	/// </summary>
 	[JsonIgnore]
 	internal int DiscriminatorInt
 		=> int.Parse(this.Discriminator, NumberStyles.Integer, CultureInfo.InvariantCulture);
 
 	/// <summary>
 	/// Gets the user's banner color, if set. Mutually exclusive with <see cref="BannerHash"/>.
 	/// </summary>
 	public virtual DiscordColor? BannerColor
 		=> !this.BannerColorInternal.HasValue ? null : new DiscordColor(this.BannerColorInternal.Value);
 
 	/// <summary>
 	/// Gets the user's theme colors, if set.
 	/// </summary>
 	public virtual IReadOnlyList<DiscordColor>? ThemeColors
 		=> !(this.ThemeColorsInternal is not null && this.ThemeColorsInternal.Count != 0) ? null : this.ThemeColorsInternal.Select(x => new DiscordColor(x)).ToList();
 
 	/// <summary>
 	/// Gets the user's banner color integer.
 	/// </summary>
 	[JsonProperty("accent_color")]
 	internal int? BannerColorInternal;
 
 	/// <summary>
 	/// Gets the user's theme color integers.
 	/// </summary>
 	[JsonProperty("theme_colors", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<int>? ThemeColorsInternal;
 
 	/// <summary>
 	/// Gets the user's banner url
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> string.IsNullOrWhiteSpace(this.BannerHash) ? null : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}?size=4096";
 
 	/// <summary>
 	/// Gets the user's profile banner hash. Mutually exclusive with <see cref="BannerColor"/>.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the users bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Bio { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string AvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's avatar decoration hash.
 	/// </summary>
 	[JsonProperty("avatar_decoration", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string AvatarDecorationHash { get; internal set; }
 
 	/// <summary>
 	/// Returns a uri to this users profile.
 	/// </summary>
 	[JsonIgnore]
 	public Uri ProfileUri => new($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.USERS}/{this.Id}");
 
 	/// <summary>
 	/// Returns a string representing the direct URL to this users profile.
 	/// </summary>
 	/// <returns>The URL of this users profile.</returns>
 	[JsonIgnore]
 	public string ProfileUrl => this.ProfileUri.AbsoluteUri;
 
 	/// <summary>
 	/// Gets the user's avatar url.
 	/// </summary>
 	[JsonIgnore]
 	public string AvatarUrl
 		=> string.IsNullOrWhiteSpace(this.AvatarHash) ? this.DefaultAvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.AvatarHash}.{(this.AvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the user's avatar decoration url.
 	/// </summary>
 	[JsonIgnore]
 	public string? AvatarDecorationUrl
 		=> string.IsNullOrWhiteSpace(this.AvatarDecorationHash) ? null : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS_DECORATIONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.AvatarDecorationHash}.{(this.AvatarDecorationHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the URL of default avatar for this user.
 	/// </summary>
 	[JsonIgnore]
 	public string DefaultAvatarUrl
 		=> $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{(this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture)}.png?size=1024";
 
 	/// <summary>
 	/// Gets whether the user is a bot.
 	/// </summary>
 	[JsonProperty("bot", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool IsBot { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user has multi-factor authentication enabled.
 	/// </summary>
 	[JsonProperty("mfa_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool? MfaEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user is an official Discord system user.
 	/// </summary>
 	[JsonProperty("system", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsSystem { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user is verified.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonProperty("verified", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool? Verified { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's email address.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonProperty("email", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Email { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's premium type.
 	/// </summary>
 	[JsonProperty("premium_type", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual PremiumType? PremiumType { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's chosen language
 	/// </summary>
 	[JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Locale { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's flags for OAuth.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual UserFlags? OAuthFlags { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's flags.
 	/// </summary>
 	[JsonProperty("public_flags", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual UserFlags? Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's pronouns.
 	/// </summary>
 	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Pronouns { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's mention string.
 	/// </summary>
 	[JsonIgnore]
 	public string Mention
 		=> Formatter.Mention(this, this is DiscordMember);
 
 	/// <summary>
 	/// Gets whether this user is the Client which created this object.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCurrent
 		=> this.Id == this.Discord.CurrentUser.Id;
 
 	#region Extension of DiscordUser
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.CertifiedModerator"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsMod
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.CertifiedModerator);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.Partner"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsPartner
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Partner);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.VerifiedBot"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsVerifiedBot
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedBot);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.VerifiedDeveloper"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsBotDev
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedDeveloper);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.Staff"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsStaff
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Staff);
 
 	#endregion
 
 	/// <summary>
 	/// Fetches the user from the API.
 	/// </summary>
 	/// <returns>The user with fresh data from the API.</returns>
 	public async Task<DiscordUser> GetFromApiAsync()
 		=> await this.Discord.ApiClient.GetUserAsync(this.Id);
 
 	/// <summary>
 	/// Whether this user is in a <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <example>
 	/// <code>
 	/// DiscordGuild guild = await Client.GetGuildAsync(806675511555915806);
 	/// DiscordUser user = await Client.GetUserAsync(469957180968271873);
 	/// Console.WriteLine($"{user.Username} {(user.IsInGuild(guild) ? "is a" : "is not a")} member of {guild.Name}");
 	/// </code>
 	/// results to <c>J_M_Lutra is a member of Project Nyaw~</c>.
 	/// </example>
 	/// <param name="guild"><see cref="DiscordGuild"/></param>
 	/// <returns><see cref="bool"/></returns>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 	public async Task<bool> IsInGuild(DiscordGuild guild)
 	{
 		try
 		{
 			var member = await guild.GetMemberAsync(this.Id);
 			return member is not null;
 
 		}
 		catch (NotFoundException)
 		{
 			return false;
 		}
 	}
 
 	/// <summary>
 	/// Whether this user is not in a <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <param name="guild"><see cref="DiscordGuild"/></param>
 	/// <returns><see cref="bool"/></returns>
 	public async Task<bool> IsNotInGuild(DiscordGuild guild)
 		=> !await this.IsInGuild(guild);
 
 	/// <summary>
 	/// Returns the DiscordMember in the specified <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <param name="guild">The <see cref="DiscordGuild"/> to get this user on.</param>
 	/// <returns>The <see cref="DiscordMember"/>.</returns>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the user is not part of the guild.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user is not part of the guild.</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<DiscordMember> ConvertToMember(DiscordGuild guild)
 		=> await guild.GetMemberAsync(this.Id);
 
 	/// <summary>
 	/// Unbans this user from a guild.
 	/// </summary>
 	/// <param name="guild">Guild to unban this user from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user 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 UnbanAsync(DiscordGuild guild, string reason = null)
 		=> guild.UnbanMemberAsync(this, reason);
 
 	/// <summary>
 	/// Gets this user's presence.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordPresence Presence
 		=> this.Discord is DiscordClient dc && dc.Presences.TryGetValue(this.Id, out var presence) ? presence : null;
 
 	/// <summary>
 	/// Gets the user's avatar URL, in requested format and size.
 	/// </summary>
 	/// <param name="fmt">Format of the avatar to get.</param>
 	/// <param name="size">Maximum size of the avatar. Must be a power of two, minimum 16, maximum 2048.</param>
 	/// <returns>URL of the user's avatar.</returns>
 	public string GetAvatarUrl(ImageFormat fmt, ushort size = 1024)
 	{
 		if (fmt == ImageFormat.Unknown)
 			throw new ArgumentException("You must specify valid image format.", nameof(fmt));
 
 		if (size < 16 || size > 2048)
 			throw new ArgumentOutOfRangeException(nameof(size));
 
 		var log = Math.Log(size, 2);
 		if (log < 4 || log > 11 || log % 1 != 0)
 			throw new ArgumentOutOfRangeException(nameof(size));
 
 		var sfmt = "";
 		sfmt = fmt switch
 		{
 			ImageFormat.Gif => "gif",
 			ImageFormat.Jpeg => "jpg",
 			ImageFormat.Png => "png",
 			ImageFormat.WebP => "webp",
 			ImageFormat.Auto => !string.IsNullOrWhiteSpace(this.AvatarHash) ? this.AvatarHash.StartsWith("a_") ? "gif" : "png" : "png",
 			_ => throw new ArgumentOutOfRangeException(nameof(fmt)),
 		};
 		var ssize = size.ToString(CultureInfo.InvariantCulture);
 		if (!string.IsNullOrWhiteSpace(this.AvatarHash))
 		{
 			var id = this.Id.ToString(CultureInfo.InvariantCulture);
 			return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{id}/{this.AvatarHash}.{sfmt}?size={ssize}";
 		}
 		else
 		{
 			var type = (this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture);
 			return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{type}.{sfmt}?size={ssize}";
 		}
 	}
 
 	/// <summary>
 	/// Returns a string representation of this user.
 	/// </summary>
 	/// <returns>String representation of this user.</returns>
 	public override string ToString() => $"User {this.Id}; {this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordUser"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordUser"/>.</returns>
 	public override bool Equals(object obj) => this.Equals(obj as DiscordUser);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordUser"/> is equal to another <see cref="DiscordUser"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordUser"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordUser"/> is equal to this <see cref="DiscordUser"/>.</returns>
 	public bool Equals(DiscordUser e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordUser"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordUser"/>.</returns>
 	public override int GetHashCode() => this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordUser"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First user to compare.</param>
 	/// <param name="e2">Second user to compare.</param>
 	/// <returns>Whether the two users are equal.</returns>
 	public static bool operator ==(DiscordUser e1, DiscordUser e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordUser"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First user to compare.</param>
 	/// <param name="e2">Second user to compare.</param>
 	/// <returns>Whether the two users are not equal.</returns>
 	public static bool operator !=(DiscordUser e1, DiscordUser e2)
 		=> !(e1 == e2);
 }
 
 /// <summary>
 /// Represents a user comparer.
 /// </summary>
 internal class DiscordUserComparer : IEqualityComparer<DiscordUser>
 {
 	/// <summary>
 	/// Whether the users are equal.
 	/// </summary>
 	/// <param name="x">The first user</param>
 	/// <param name="y">The second user.</param>
 	public bool Equals(DiscordUser x, DiscordUser y) => x.Equals(y);
 
 	/// <summary>
 	/// Gets the hash code.
 	/// </summary>
 	/// <param name="obj">The user.</param>
 	public int GetHashCode(DiscordUser obj) => obj.Id.GetHashCode();
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhook.cs b/DisCatSharp/Entities/Webhook/DiscordWebhook.cs
index 90094ebbb..0852aade4 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhook.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhook.cs
@@ -1,279 +1,279 @@
 // 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.IO;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents information about a Discord webhook.
 /// </summary>
 public class DiscordWebhook : SnowflakeObject, IEquatable<DiscordWebhook>
 {
 	/// <summary>
 	/// Gets the api client.
 	/// </summary>
 	internal DiscordApiClient ApiClient { get; set; }
 
 	/// <summary>
 	/// Gets the id of the guild this webhook belongs to.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the channel this webhook belongs to.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the user this webhook was created by.
 	/// </summary>
 	[JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the default name of this webhook.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets hash of the default avatar for this webhook.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	internal string AvatarHash { get; set; }
 
 	/// <summary>
 	/// Gets the partial source guild for this webhook (For Channel Follower Webhooks).
 	/// </summary>
 	[JsonProperty("source_guild", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordGuild SourceGuild { get; set; }
 
 	/// <summary>
 	/// Gets the partial source channel for this webhook (For Channel Follower Webhooks).
 	/// </summary>
 	[JsonProperty("source_channel", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordChannel SourceChannel { get; set; }
 
 	/// <summary>
 	/// Gets the url used for executing the webhook.
 	/// </summary>
 	[JsonProperty("url", NullValueHandling = NullValueHandling.Ignore)]
 	public string Url { get; set; }
 
 	/// <summary>
 	/// Gets the default avatar url for this webhook.
 	/// </summary>
 	public string AvatarUrl
 		=> !string.IsNullOrWhiteSpace(this.AvatarHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{this.Id}/{this.AvatarHash}.png?size=1024" : null;
 
 	/// <summary>
 	/// Gets the secure token of this webhook.
 	/// </summary>
 	[JsonProperty("token", NullValueHandling = NullValueHandling.Ignore)]
 	public string Token { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordWebhook"/> class.
 	/// </summary>
 	internal DiscordWebhook()
 	{ }
 
 	/// <summary>
 	/// Modifies this webhook.
 	/// </summary>
 	/// <param name="name">New default name for this webhook.</param>
 	/// <param name="avatar">New avatar for this webhook.</param>
 	/// <param name="channelId">The new channel id to move the webhook to.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The modified webhook.</returns>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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<DiscordWebhook> ModifyAsync(string name = null, Optional<Stream> avatar = default, ulong? channelId = null, string reason = null)
 	{
 		var avatarb64 = ImageTool.Base64FromStream(avatar);
 
 		var newChannelId = channelId ?? this.ChannelId;
 
 		return this.Discord.ApiClient.ModifyWebhookAsync(this.Id, newChannelId, name, avatarb64, reason);
 	}
 
 	/// <summary>
 	/// Gets a previously-sent webhook message.
 	/// </summary>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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 messageId)
 		=> await (this.Discord?.ApiClient ?? this.ApiClient).GetWebhookMessageAsync(this.Id, this.Token, messageId).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets a previously-sent webhook message.
 	/// </summary>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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 messageId, ulong threadId)
 		=> await (this.Discord?.ApiClient ?? this.ApiClient).GetWebhookMessageAsync(this.Id, this.Token, messageId, threadId).ConfigureAwait(false);
 
 	/// <summary>
 	/// Permanently deletes this webhook.
 	/// </summary>
-	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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()
 		=> this.Discord.ApiClient.DeleteWebhookAsync(this.Id, this.Token);
 
 	/// <summary>
 	/// Executes this webhook with the given <see cref="DiscordWebhookBuilder"/>.
 	/// </summary>
 	/// <param name="builder">Webhook builder filled with data to send.</param>
 	/// <param name="threadId">Target thread id (Optional). Defaults to null.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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> ExecuteAsync(DiscordWebhookBuilder builder, string threadId = null)
 		=> (this.Discord?.ApiClient ?? this.ApiClient).ExecuteWebhookAsync(this.Id, this.Token, builder, threadId);
 
 	/// <summary>
 	/// Executes this webhook in Slack compatibility mode.
 	/// </summary>
 	/// <param name="json">JSON containing Slack-compatible payload for this webhook.</param>
 	/// <param name="threadId">Target thread id (Optional). Defaults to null.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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 ExecuteSlackAsync(string json, string threadId = null)
 		=> (this.Discord?.ApiClient ?? this.ApiClient).ExecuteWebhookSlackAsync(this.Id, this.Token, json, threadId);
 
 	/// <summary>
 	/// Executes this webhook in GitHub compatibility mode.
 	/// </summary>
 	/// <param name="json">JSON containing GitHub-compatible payload for this webhook.</param>
 	/// <param name="threadId">Target thread id (Optional). Defaults to null.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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 ExecuteGithubAsync(string json, string threadId = null)
 		=> (this.Discord?.ApiClient ?? this.ApiClient).ExecuteWebhookGithubAsync(this.Id, this.Token, json, threadId);
 
 	/// <summary>
 	/// Edits a previously-sent webhook message.
 	/// </summary>
 	/// <param name="messageId">The id of the message to edit.</param>
 	/// <param name="builder">The builder of the message to edit.</param>
 	/// <param name="threadId">Target thread id (Optional). Defaults to null.</param>
 	/// <returns>The modified <see cref="DiscordMessage"/></returns>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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> EditMessageAsync(ulong messageId, DiscordWebhookBuilder builder, string threadId = null)
 	{
 		builder.Validate(true);
 		if (builder.KeepAttachmentsInternal.HasValue && builder.KeepAttachmentsInternal.Value)
 		{
 			builder.AttachmentsInternal.AddRange(this.ApiClient.GetWebhookMessageAsync(this.Id, this.Token, messageId.ToString(), threadId).Result.Attachments);
 		}
 		else if (builder.KeepAttachmentsInternal.HasValue)
 		{
 			builder.AttachmentsInternal.Clear();
 		}
 		return await (this.Discord?.ApiClient ?? this.ApiClient).EditWebhookMessageAsync(this.Id, this.Token, messageId.ToString(), builder, threadId).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a message that was created by the webhook.
 	/// </summary>
 	/// <param name="messageId">The id of the message to delete</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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(ulong messageId)
 		=> (this.Discord?.ApiClient ?? this.ApiClient).DeleteWebhookMessageAsync(this.Id, this.Token, messageId);
 
 	/// <summary>
 	/// Deletes a message that was created by the webhook.
 	/// </summary>
 	/// <param name="messageId">The id of the message to delete</param>
 	/// <param name="threadId">Target thread id (Optional). Defaults to null.</param>
-	/// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
-	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
-	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	/// <exception cref="NotFoundException">Thrown when the webhook 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(ulong messageId, ulong threadId)
 		=> (this.Discord?.ApiClient ?? this.ApiClient).DeleteWebhookMessageAsync(this.Id, this.Token, messageId, threadId);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordWebhook"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordWebhook"/>.</returns>
 	public override bool Equals(object obj) => this.Equals(obj as DiscordWebhook);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordWebhook"/> is equal to another <see cref="DiscordWebhook"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordWebhook"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordWebhook"/> is equal to this <see cref="DiscordWebhook"/>.</returns>
 	public bool Equals(DiscordWebhook e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordWebhook"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordWebhook"/>.</returns>
 	public override int GetHashCode() => this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordWebhook"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First webhook to compare.</param>
 	/// <param name="e2">Second webhook to compare.</param>
 	/// <returns>Whether the two webhooks are equal.</returns>
 	public static bool operator ==(DiscordWebhook e1, DiscordWebhook 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="DiscordWebhook"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First webhook to compare.</param>
 	/// <param name="e2">Second webhook to compare.</param>
 	/// <returns>Whether the two webhooks are not equal.</returns>
 	public static bool operator !=(DiscordWebhook e1, DiscordWebhook e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
index c1d110702..fe6d548ff 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
@@ -1,462 +1,462 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Constructs ready-to-send webhook requests.
 /// </summary>
 public sealed class DiscordWebhookBuilder
 {
 	/// <summary>
 	/// Username to use for this webhook request.
 	/// </summary>
 	public Optional<string> Username { get; set; }
 
 	/// <summary>
 	/// Avatar url to use for this webhook request.
 	/// </summary>
 	public Optional<string> AvatarUrl { get; set; }
 
 	/// <summary>
 	/// Whether this webhook request is text-to-speech.
 	/// </summary>
 	public bool IsTts { get; set; }
 
 	/// <summary>
 	/// Message to send on this webhook request.
 	/// </summary>
 	public string Content
 	{
 		get => this._content;
 		set
 		{
 			if (value != null && value.Length > 2000)
 				throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
 			this._content = value;
 		}
 	}
 	private string _content;
 
 	/// <summary>
 	/// Name of the new thread.
 	/// Only works if the webhook is send in a <see cref="ChannelType.Forum"/>.
 	/// </summary>
 	public string ThreadName { get; set; }
 
 
 	/// <summary>
 	/// Whether to keep previous attachments.
 	/// </summary>
 	internal bool? KeepAttachmentsInternal;
 
 	/// <summary>
 	/// Embeds to send on this webhook request.
 	/// </summary>
 	public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 	private readonly List<DiscordEmbed> _embeds = new();
 
 	/// <summary>
 	/// Files to send on this webhook request.
 	/// </summary>
 	public IReadOnlyList<DiscordMessageFile> Files => this._files;
 	private readonly List<DiscordMessageFile> _files = new();
 
 	/// <summary>
 	/// Mentions to send on this webhook request.
 	/// </summary>
 	public IReadOnlyList<IMention> Mentions => this._mentions;
 	private readonly List<IMention> _mentions = new();
 
 	/// <summary>
 	/// Gets the components.
 	/// </summary>
 	public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
 	private readonly List<DiscordActionRowComponent> _components = new();
 
 
 	/// <summary>
 	/// Attachments to keep on this webhook request.
 	/// </summary>
 	public IEnumerable<DiscordAttachment> Attachments => this.AttachmentsInternal;
 	internal readonly List<DiscordAttachment> AttachmentsInternal = new();
 
 	/// <summary>
 	/// Constructs a new empty webhook request builder.
 	/// </summary>
 	public DiscordWebhookBuilder() { } // I still see no point in initializing collections with empty collections. //
 
 
 	/// <summary>
 	/// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
 	/// </summary>
 	/// <param name="components">The components to add to the builder.</param>
 	/// <returns>The current builder to be chained.</returns>
-	/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
+	/// <exception cref="ArgumentOutOfRangeException">No components were passed.</exception>
 	public DiscordWebhookBuilder AddComponents(params DiscordComponent[] components)
 		=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
 	/// <summary>
 	/// Appends several rows of components to the builder
 	/// </summary>
 	/// <param name="components">The rows of components to add, holding up to five each.</param>
 	/// <returns></returns>
 	public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 	{
 		var ara = components.ToArray();
 
 		if (ara.Length + this._components.Count > 5)
 			throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 		foreach (var ar in ara)
 			this._components.Add(ar);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
 	/// </summary>
 	/// <param name="components">The components to add to the builder.</param>
 	/// <returns>The current builder to be chained.</returns>
-	/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
+	/// <exception cref="ArgumentOutOfRangeException">No components were passed.</exception>
 	public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordComponent> components)
 	{
 		var cmpArr = components.ToArray();
 		var count = cmpArr.Length;
 
 		if (!cmpArr.Any())
 			throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
 		if (count > 5)
 			throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 		var comp = new DiscordActionRowComponent(cmpArr);
 		this._components.Add(comp);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the username for this webhook builder.
 	/// </summary>
 	/// <param name="username">Username of the webhook</param>
 	public DiscordWebhookBuilder WithUsername(string username)
 	{
 		this.Username = username;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the avatar of this webhook builder from its url.
 	/// </summary>
 	/// <param name="avatarUrl">Avatar url of the webhook</param>
 	public DiscordWebhookBuilder WithAvatarUrl(string avatarUrl)
 	{
 		this.AvatarUrl = avatarUrl;
 		return this;
 	}
 
 	/// <summary>
 	/// Indicates if the webhook must use text-to-speech.
 	/// </summary>
 	/// <param name="tts">Text-to-speech</param>
 	public DiscordWebhookBuilder WithTts(bool tts)
 	{
 		this.IsTts = tts;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the message to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="content">Message to send.</param>
 	public DiscordWebhookBuilder WithContent(string content)
 	{
 		this.Content = content;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the thread name to create at the execution of the webhook.
 	/// Only works for <see cref="ChannelType.Forum"/>.
 	/// </summary>
 	/// <param name="name">The thread name.</param>
 	public DiscordWebhookBuilder WithThreadName(string name)
 	{
 		this.ThreadName = name;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds an embed to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="embed">Embed to add.</param>
 	public DiscordWebhookBuilder AddEmbed(DiscordEmbed embed)
 	{
 		if (embed != null)
 			this._embeds.Add(embed);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given embeds to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="embeds">Embeds to add.</param>
 	public DiscordWebhookBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 	{
 		this._embeds.AddRange(embeds);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a file to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="filename">Name of the file.</param>
 	/// <param name="data">File data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	public DiscordWebhookBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == filename))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(filename, data, data.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(filename, data, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="stream">The Stream to the file.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns></returns>
 	public DiscordWebhookBuilder AddFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == stream.Name))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given files to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="files">Dictionary of file name and file data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	public DiscordWebhookBuilder AddFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 	{
 		if (this.Files.Count + files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		foreach (var file in files)
 		{
 			if (this._files.Any(x => x.FileName == file.Key))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 			else
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
 		}
 
 
 		return this;
 	}
 
 	/// <summary>
 	/// Modifies the given attachments on edit.
 	/// </summary>
 	/// <param name="attachments">Attachments to edit.</param>
 	/// <returns></returns>
 	public DiscordWebhookBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
 	{
 		this.AttachmentsInternal.AddRange(attachments);
 		return this;
 	}
 
 	/// <summary>
 	/// Whether to keep the message attachments, if new ones are added.
 	/// </summary>
 	/// <returns></returns>
 	public DiscordWebhookBuilder KeepAttachments(bool keep)
 	{
 		this.KeepAttachmentsInternal = keep;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mention to the mentions to parse, etc. at the execution of the webhook.
 	/// </summary>
 	/// <param name="mention">Mention to add.</param>
 	public DiscordWebhookBuilder AddMention(IMention mention)
 	{
 		this._mentions.Add(mention);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mentions to the mentions to parse, etc. at the execution of the webhook.
 	/// </summary>
 	/// <param name="mentions">Mentions to add.</param>
 	public DiscordWebhookBuilder AddMentions(IEnumerable<IMention> mentions)
 	{
 		this._mentions.AddRange(mentions);
 		return this;
 	}
 
 	/// <summary>
 	/// Executes a webhook.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <returns>The message sent</returns>
 	public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook) => await webhook.ExecuteAsync(this).ConfigureAwait(false);
 
 	/// <summary>
 	/// Executes a webhook.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="threadId">Target thread id.</param>
 	/// <returns>The message sent</returns>
 	public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook, ulong threadId) => await webhook.ExecuteAsync(this, threadId.ToString()).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="message">The message to modify.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message) => await this.ModifyAsync(webhook, message.Id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="messageId">The id of the message to modify.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId) => await webhook.EditMessageAsync(messageId, this).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="message">The message to modify.</param>
 	/// <param name="thread">Target thread.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message, DiscordThreadChannel thread) => await this.ModifyAsync(webhook, message.Id, thread.Id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="messageId">The id of the message to modify.</param>
 	/// <param name="threadId">Target thread id.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId, ulong threadId) => await webhook.EditMessageAsync(messageId, this, threadId.ToString()).ConfigureAwait(false);
 
 	/// <summary>
 	/// Clears all message components on this builder.
 	/// </summary>
 	public void ClearComponents()
 		=> this._components.Clear();
 
 	/// <summary>
 	/// Allows for clearing the Webhook Builder so that it can be used again to send a new message.
 	/// </summary>
 	public void Clear()
 	{
 		this.Content = "";
 		this._embeds.Clear();
 		this.IsTts = false;
 		this._mentions.Clear();
 		this._files.Clear();
 		this.AttachmentsInternal.Clear();
 		this._components.Clear();
 		this.KeepAttachmentsInternal = false;
 		this.ThreadName = null;
 	}
 
 	/// <summary>
 	/// Does the validation before we send a the Create/Modify request.
 	/// </summary>
 	/// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
 	/// <param name="isFollowup">Tells the method to perform the follow up message validation.</param>
 	/// <param name="isInteractionResponse">Tells the method to perform the interaction response validation.</param>
 	internal void Validate(bool isModify = false, bool isFollowup = false, bool isInteractionResponse = false)
 	{
 		if (isModify)
 		{
 			if (this.Username.HasValue)
 				throw new ArgumentException("You cannot change the username of a message.");
 
 			if (this.AvatarUrl.HasValue)
 				throw new ArgumentException("You cannot change the avatar of a message.");
 		}
 		else if (isFollowup)
 		{
 			if (this.Username.HasValue)
 				throw new ArgumentException("You cannot change the username of a follow up message.");
 
 			if (this.AvatarUrl.HasValue)
 				throw new ArgumentException("You cannot change the avatar of a follow up message.");
 		}
 		else if (isInteractionResponse)
 		{
 			if (this.Username.HasValue)
 				throw new ArgumentException("You cannot change the username of an interaction response.");
 
 			if (this.AvatarUrl.HasValue)
 				throw new ArgumentException("You cannot change the avatar of an interaction response.");
 		}
 		else
 		{
 			if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && !this.Embeds.Any() && !this.Components.Any())
 				throw new ArgumentException("You must specify content, an embed, a component, or at least one file.");
 		}
 	}
 }
diff --git a/DisCatSharp/Exceptions/BadRequestException.cs b/DisCatSharp/Exceptions/BadRequestException.cs
index 490842894..b2420d5de 100644
--- a/DisCatSharp/Exceptions/BadRequestException.cs
+++ b/DisCatSharp/Exceptions/BadRequestException.cs
@@ -1,86 +1,86 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when a malformed request is sent.
 /// </summary>
 public class BadRequestException : Exception
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the error code for this exception.
 	/// </summary>
 	public int Code { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON message received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
 	/// Gets the form error responses in JSON format.
 	/// </summary>
 	public string Errors { get; internal set; }
 
 	/// <summary>
-	/// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.BadRequestException"/> class.
+	/// Initializes a new instance of the <see cref="BadRequestException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
 	internal BadRequestException(BaseRestRequest request, RestResponse response) : base("Bad request: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["code"] != null)
 				this.Code = (int)j["code"];
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 
 			if (j["errors"] != null)
 				this.Errors = j["errors"].ToString();
 		}
 		catch { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/NotFoundException.cs b/DisCatSharp/Exceptions/NotFoundException.cs
index 76bb50d24..55232657b 100644
--- a/DisCatSharp/Exceptions/NotFoundException.cs
+++ b/DisCatSharp/Exceptions/NotFoundException.cs
@@ -1,70 +1,70 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when a requested resource is not found.
 /// </summary>
 public class NotFoundException : Exception
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
-	/// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.NotFoundException"/> class.
+	/// Initializes a new instance of the <see cref="NotFoundException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
 	internal NotFoundException(BaseRestRequest request, RestResponse response) : base("Not found: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/ServerErrorException.cs b/DisCatSharp/Exceptions/ServerErrorException.cs
index 837c1c1e5..f9cf0be55 100644
--- a/DisCatSharp/Exceptions/ServerErrorException.cs
+++ b/DisCatSharp/Exceptions/ServerErrorException.cs
@@ -1,70 +1,70 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when Discord returns an Internal Server Error.
 /// </summary>
 public class ServerErrorException : Exception
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
-	/// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.ServerErrorException"/> class.
+	/// Initializes a new instance of the <see cref="ServerErrorException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
 	internal ServerErrorException(BaseRestRequest request, RestResponse response) : base("Internal Server Error: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/Exceptions/UnauthorizedException.cs b/DisCatSharp/Exceptions/UnauthorizedException.cs
index aaad0898c..95bc91608 100644
--- a/DisCatSharp/Exceptions/UnauthorizedException.cs
+++ b/DisCatSharp/Exceptions/UnauthorizedException.cs
@@ -1,70 +1,70 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 
 using DisCatSharp.Net;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Exceptions;
 
 /// <summary>
 /// Represents an exception thrown when requester doesn't have necessary permissions to complete the request.
 /// </summary>
 public class UnauthorizedException : Exception
 {
 	/// <summary>
 	/// Gets the request that caused the exception.
 	/// </summary>
 	public BaseRestRequest WebRequest { get; internal set; }
 
 	/// <summary>
 	/// Gets the response to the request.
 	/// </summary>
 	public RestResponse WebResponse { get; internal set; }
 
 	/// <summary>
 	/// Gets the JSON received.
 	/// </summary>
 	public string JsonMessage { get; internal set; }
 
 	/// <summary>
-	/// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.UnauthorizedException"/> class.
+	/// Initializes a new instance of the <see cref="UnauthorizedException"/> class.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="response">The response.</param>
 	internal UnauthorizedException(BaseRestRequest request, RestResponse response) : base("Unauthorized: " + response.ResponseCode)
 	{
 		this.WebRequest = request;
 		this.WebResponse = response;
 
 		try
 		{
 			var j = JObject.Parse(response.Response);
 
 			if (j["message"] != null)
 				this.JsonMessage = j["message"].ToString();
 		}
 		catch (Exception) { }
 	}
 }
diff --git a/DisCatSharp/RingBuffer.cs b/DisCatSharp/RingBuffer.cs
index 0e7d74b98..fd0f7addf 100644
--- a/DisCatSharp/RingBuffer.cs
+++ b/DisCatSharp/RingBuffer.cs
@@ -1,238 +1,238 @@
 // 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;
 using System.Collections.Generic;
 using System.Linq;
 
 using DisCatSharp.Common;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A circular buffer collection.
 /// </summary>
 /// <typeparam name="T">Type of elements within this ring buffer.</typeparam>
 public class RingBuffer<T> : ICollection<T>
 {
 	/// <summary>
 	/// Gets the current index of the buffer items.
 	/// </summary>
 	public int CurrentIndex { get; protected set; }
 
 	/// <summary>
 	/// Gets the capacity of this ring buffer.
 	/// </summary>
 	public int Capacity { get; protected set; }
 
 	/// <summary>
 	/// Gets the number of items in this ring buffer.
 	/// </summary>
 	public int Count
 		=> this._reachedEnd ? this.Capacity : this.CurrentIndex;
 
 	/// <summary>
 	/// Gets whether this ring buffer is read-only.
 	/// </summary>
 	public bool IsReadOnly
 		=> false;
 
 	/// <summary>
 	/// Gets or sets the internal collection of items.
 	/// </summary>
 	protected T[] InternalBuffer { get; set; }
 	private bool _reachedEnd;
 
 	/// <summary>
 	/// Creates a new ring buffer with specified size.
 	/// </summary>
 	/// <param name="size">Size of the buffer to create.</param>
-	/// <exception cref="System.ArgumentOutOfRangeException" />
+	/// <exception cref="ArgumentOutOfRangeException" />
 	public RingBuffer(int size)
 	{
 		if (size <= 0)
 			throw new ArgumentOutOfRangeException(nameof(size), "Size must be positive.");
 
 		this.CurrentIndex = 0;
 		this.Capacity = size;
 		this.InternalBuffer = new T[this.Capacity];
 	}
 
 	/// <summary>
 	/// Creates a new ring buffer, filled with specified elements.
 	/// </summary>
 	/// <param name="elements">Elements to fill the buffer with.</param>
-	/// <exception cref="System.ArgumentException" />
-	/// <exception cref="System.ArgumentOutOfRangeException" />
+	/// <exception cref="ArgumentException" />
+	/// <exception cref="ArgumentOutOfRangeException" />
 	public RingBuffer(IEnumerable<T> elements)
 		: this(elements, 0)
 	{ }
 
 	/// <summary>
 	/// Creates a new ring buffer, filled with specified elements, and starting at specified index.
 	/// </summary>
 	/// <param name="elements">Elements to fill the buffer with.</param>
 	/// <param name="index">Starting element index.</param>
-	/// <exception cref="System.ArgumentException" />
-	/// <exception cref="System.ArgumentOutOfRangeException" />
+	/// <exception cref="ArgumentException" />
+	/// <exception cref="ArgumentOutOfRangeException" />
 	public RingBuffer(IEnumerable<T> elements, int index)
 	{
 		if (elements == null || !elements.Any())
 			throw new ArgumentException("The collection cannot be null or empty.", nameof(elements));
 
 		this.CurrentIndex = index;
 		this.InternalBuffer = elements.ToArray();
 		this.Capacity = this.InternalBuffer.Length;
 
 		if (this.CurrentIndex >= this.InternalBuffer.Length || this.CurrentIndex < 0)
 			throw new ArgumentOutOfRangeException(nameof(index), "Index must be less than buffer capacity, and greater than zero.");
 	}
 
 	/// <summary>
 	/// Inserts an item into this ring buffer.
 	/// </summary>
 	/// <param name="item">Item to insert.</param>
 	public void Add(T item)
 	{
 		this.InternalBuffer[this.CurrentIndex++] = item;
 
 		if (this.CurrentIndex == this.Capacity)
 		{
 			this.CurrentIndex = 0;
 			this._reachedEnd = true;
 		}
 	}
 
 	/// <summary>
 	/// Gets first item from the buffer that matches the predicate.
 	/// </summary>
 	/// <param name="predicate">Predicate used to find the item.</param>
 	/// <param name="item">Item that matches the predicate, or default value for the type of the items in this ring buffer, if one is not found.</param>
 	/// <returns>Whether an item that matches the predicate was found or not.</returns>
 	public bool TryGet(Func<T, bool> predicate, out T item)
 	{
 		for (var i = this.CurrentIndex; i < this.InternalBuffer.Length; i++)
 		{
 			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 			{
 				item = this.InternalBuffer[i];
 				return true;
 			}
 		}
 		for (var i = 0; i < this.CurrentIndex; i++)
 		{
 			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 			{
 				item = this.InternalBuffer[i];
 				return true;
 			}
 		}
 
 		item = default;
 		return false;
 	}
 
 	/// <summary>
 	/// Clears this ring buffer and resets the current item index.
 	/// </summary>
 	public void Clear()
 	{
 		this.InternalBuffer.Populate(default);
 		this.CurrentIndex = 0;
 	}
 
 	/// <summary>
 	/// Checks whether given item is present in the buffer. This method is not implemented. Use <see cref="Contains(Func{T, bool})"/> instead.
 	/// </summary>
 	/// <param name="item">Item to check for.</param>
 	/// <returns>Whether the buffer contains the item.</returns>
-	/// <exception cref="System.NotImplementedException" />
+	/// <exception cref="NotImplementedException" />
 	public bool Contains(T item) => throw new NotImplementedException("This method is not implemented. Use .Contains(predicate) instead.");
 
 	/// <summary>
 	/// Checks whether given item is present in the buffer using given predicate to find it.
 	/// </summary>
 	/// <param name="predicate">Predicate used to check for the item.</param>
 	/// <returns>Whether the buffer contains the item.</returns>
 	public bool Contains(Func<T, bool> predicate) => this.InternalBuffer.Any(predicate);
 
 	/// <summary>
 	/// Copies this ring buffer to target array, attempting to maintain the order of items within.
 	/// </summary>
 	/// <param name="array">Target array.</param>
 	/// <param name="index">Index starting at which to copy the items to.</param>
 	public void CopyTo(T[] array, int index)
 	{
 		if (array.Length - index < 1)
 			throw new ArgumentException("Target array is too small to contain the elements from this buffer.", nameof(array));
 
 		var ci = 0;
 		for (var i = this.CurrentIndex; i < this.InternalBuffer.Length; i++)
 			array[ci++] = this.InternalBuffer[i];
 		for (var i = 0; i < this.CurrentIndex; i++)
 			array[ci++] = this.InternalBuffer[i];
 	}
 
 	/// <summary>
 	/// Removes an item from the buffer. This method is not implemented. Use <see cref="Remove(Func{T, bool})"/> instead.
 	/// </summary>
 	/// <param name="item">Item to remove.</param>
 	/// <returns>Whether an item was removed or not.</returns>
 	public bool Remove(T item) => throw new NotImplementedException("This method is not implemented. Use .Remove(predicate) instead.");
 
 	/// <summary>
 	/// Removes an item from the buffer using given predicate to find it.
 	/// </summary>
 	/// <param name="predicate">Predicate used to find the item.</param>
 	/// <returns>Whether an item was removed or not.</returns>
 	public bool Remove(Func<T, bool> predicate)
 	{
 		for (var i = 0; i < this.InternalBuffer.Length; i++)
 		{
 			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 			{
 				this.InternalBuffer[i] = default;
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Returns an enumerator for this ring buffer.
 	/// </summary>
 	/// <returns>Enumerator for this ring buffer.</returns>
 	public IEnumerator<T> GetEnumerator() =>
 		!this._reachedEnd
 			? this.InternalBuffer.AsEnumerable().GetEnumerator()
 			: this.InternalBuffer.Skip(this.CurrentIndex)
 				.Concat(this.InternalBuffer.Take(this.CurrentIndex))
 				.GetEnumerator();
 
 	/// <summary>
 	/// Returns an enumerator for this ring buffer.
 	/// </summary>
 	/// <returns>Enumerator for this ring buffer.</returns>
 	IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 }
diff --git a/DisCatSharp/Utilities.cs b/DisCatSharp/Utilities.cs
index 566a79c00..c6324ec16 100644
--- a/DisCatSharp/Utilities.cs
+++ b/DisCatSharp/Utilities.cs
@@ -1,470 +1,470 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Various Discord-related utilities.
 /// </summary>
 public static class Utilities
 {
 	/// <summary>
 	/// Gets the version of the library
 	/// </summary>
 	internal static string VersionHeader { get; set; }
 
 	/// <summary>
 	/// Gets or sets the permission strings.
 	/// </summary>
 	internal static Dictionary<Permissions, string> PermissionStrings { get; set; }
 
 	/// <summary>
 	/// Gets the utf8 encoding
 	/// </summary>
 	// ReSharper disable once InconsistentNaming
 	internal static UTF8Encoding UTF8 { get; } = new(false);
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="Utilities"/> class.
 	/// </summary>
 	static Utilities()
 	{
 		PermissionStrings = new Dictionary<Permissions, string>();
 		var t = typeof(Permissions);
 		var ti = t.GetTypeInfo();
 		var vals = Enum.GetValues(t).Cast<Permissions>();
 
 		foreach (var xv in vals)
 		{
 			var xsv = xv.ToString();
 			var xmv = ti.DeclaredMembers.FirstOrDefault(xm => xm.Name == xsv);
 			var xav = xmv.GetCustomAttribute<PermissionStringAttribute>();
 
 			PermissionStrings[xv] = xav.String;
 		}
 
 		var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
 		var vs = "";
 		var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (iv != null)
 			vs = iv.InformationalVersion;
 		else
 		{
 			var v = a.GetName().Version;
 			vs = v.ToString(3);
 		}
 
 		VersionHeader = $"DiscordBot (https://github.com/Aiko-IT-Systems/DisCatSharp, v{vs})";
 	}
 
 	/// <summary>
 	/// Gets the api base uri.
 	/// </summary>
 	/// <param name="config">The config</param>
 	/// <returns>A string.</returns>
 	internal static string GetApiBaseUri(DiscordConfiguration config = null)
 		=> config == null ? Endpoints.BASE_URI + "9" : config.UseCanary ? Endpoints.CANARY_URI + config.ApiVersion : Endpoints.BASE_URI + config.ApiVersion;
 
 	/// <summary>
 	/// Gets the api uri for.
 	/// </summary>
 	/// <param name="path">The path.</param>
 	/// <param name="config">The config</param>
 	/// <returns>An Uri.</returns>
 	internal static Uri GetApiUriFor(string path, DiscordConfiguration config)
 		=> new($"{GetApiBaseUri(config)}{path}");
 
 	/// <summary>
 	/// Gets the api uri for.
 	/// </summary>
 	/// <param name="path">The path.</param>
 	/// <param name="queryString">The query string.</param>
 	/// <param name="config">The config</param>
 	/// <returns>An Uri.</returns>
 	internal static Uri GetApiUriFor(string path, string queryString, DiscordConfiguration config)
 		=> new($"{GetApiBaseUri(config)}{path}{queryString}");
 
 	/// <summary>
 	/// Gets the api uri builder for.
 	/// </summary>
 	/// <param name="path">The path.</param>
 	/// <param name="config">The config</param>
 	/// <returns>A QueryUriBuilder.</returns>
 	internal static QueryUriBuilder GetApiUriBuilderFor(string path, DiscordConfiguration config)
 		=> new($"{GetApiBaseUri(config)}{path}");
 
 	/// <summary>
 	/// Gets the formatted token.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <returns>A string.</returns>
 	internal static string GetFormattedToken(BaseDiscordClient client) => GetFormattedToken(client.Configuration);
 
 	/// <summary>
 	/// Gets the formatted token.
 	/// </summary>
 	/// <param name="config">The config.</param>
 	/// <returns>A string.</returns>
 	internal static string GetFormattedToken(DiscordConfiguration config) =>
 		config.TokenType switch
 		{
 			TokenType.Bearer => $"Bearer {config.Token}",
 			TokenType.Bot => $"Bot {config.Token}",
 			_ => throw new ArgumentException("Invalid token type specified.", nameof(config)),
 		};
 
 	/// <summary>
 	/// Gets the base headers.
 	/// </summary>
 	/// <returns>A Dictionary.</returns>
 	internal static Dictionary<string, string> GetBaseHeaders()
 		=> new();
 
 	/// <summary>
 	/// Gets the user agent.
 	/// </summary>
 	/// <returns>A string.</returns>
 	internal static string GetUserAgent()
 		=> VersionHeader;
 
 	/// <summary>
 	/// Contains the user mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsUserMentions(string message)
 	{
 		var pattern = @"<@(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the nickname mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsNicknameMentions(string message)
 	{
 		var pattern = @"<@!(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the channel mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsChannelMentions(string message)
 	{
 		var pattern = @"<#(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the role mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsRoleMentions(string message)
 	{
 		var pattern = @"<@&(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the emojis.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsEmojis(string message)
 	{
 		var pattern = @"<a?:(.*):(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Gets the user mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetUserMentions(DiscordMessage message)
 	{
 		var regex = new Regex(@"<@!?(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets the role mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetRoleMentions(DiscordMessage message)
 	{
 		var regex = new Regex(@"<@&(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets the channel mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetChannelMentions(DiscordMessage message)
 	{
 		var regex = new Regex(@"<#(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets the emojis.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetEmojis(DiscordMessage message)
 	{
 		var regex = new Regex(@"<a?:([a-zA-Z0-9_]+):(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Are the valid slash command name.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <returns>A bool.</returns>
 	internal static bool IsValidSlashCommandName(string name)
 	{
 		var regex = new Regex(@"^[\w-]{1,32}$");
 		return regex.IsMatch(name);
 	}
 
 	/// <summary>
 	/// Checks the thread auto archive duration feature.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="taad">The taad.</param>
 	/// <returns>A bool.</returns>
 	internal static bool CheckThreadAutoArchiveDurationFeature(DiscordGuild guild, ThreadAutoArchiveDuration taad)
 		=> true;
 
 	/// <summary>
 	/// Checks the thread private feature.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <returns>A bool.</returns>
 	internal static bool CheckThreadPrivateFeature(DiscordGuild guild) => guild.PremiumTier.HasFlag(PremiumTier.TierTwo) || guild.Features.CanCreatePrivateThreads;
 
 	/// <summary>
 	/// Have the message intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasMessageIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages);
 
 	/// <summary>
 	/// Have the message intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasMessageContentIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.MessageContent);
 
 	/// <summary>
 	/// Have the reaction intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasReactionIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.GuildMessageReactions) || intents.HasIntent(DiscordIntents.DirectMessageReactions);
 
 	/// <summary>
 	/// Have the typing intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasTypingIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.GuildMessageTyping) || intents.HasIntent(DiscordIntents.DirectMessageTyping);
 
 	// https://discord.com/developers/docs/topics/gateway#sharding-sharding-formula
 	/// <summary>
 	/// Gets a shard id from a guild id and total shard count.
 	/// </summary>
 	/// <param name="guildId">The guild id the shard is on.</param>
 	/// <param name="shardCount">The total amount of shards.</param>
 	/// <returns>The shard id.</returns>
 	public static int GetShardId(ulong guildId, int shardCount)
 		=> (int)(guildId >> 22) % shardCount;
 
 	/// <summary>
-	/// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
+	/// Helper method to create a <see cref="DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
 	/// </summary>
 	/// <param name="unixTime">Unix time seconds to convert.</param>
 	/// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
-	/// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
+	/// <returns>Calculated <see cref="DateTimeOffset"/>.</returns>
 	public static DateTimeOffset GetDateTimeOffset(long unixTime, bool shouldThrow = true)
 	{
 		try
 		{
 			return DateTimeOffset.FromUnixTimeSeconds(unixTime);
 		}
 		catch (Exception)
 		{
 			if (shouldThrow)
 				throw;
 
 			return DateTimeOffset.MinValue;
 		}
 	}
 
 	/// <summary>
-	/// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
+	/// Helper method to create a <see cref="DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
 	/// </summary>
 	/// <param name="unixTime">Unix time milliseconds to convert.</param>
 	/// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
-	/// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
+	/// <returns>Calculated <see cref="DateTimeOffset"/>.</returns>
 	public static DateTimeOffset GetDateTimeOffsetFromMilliseconds(long unixTime, bool shouldThrow = true)
 	{
 		try
 		{
 			return DateTimeOffset.FromUnixTimeMilliseconds(unixTime);
 		}
 		catch (Exception)
 		{
 			if (shouldThrow)
 				throw;
 
 			return DateTimeOffset.MinValue;
 		}
 	}
 
 	/// <summary>
-	/// Helper method to calculate Unix time seconds from a <see cref="System.DateTimeOffset"/> for targets that do not support this natively.
+	/// Helper method to calculate Unix time seconds from a <see cref="DateTimeOffset"/> for targets that do not support this natively.
 	/// </summary>
-	/// <param name="dto"><see cref="System.DateTimeOffset"/> to calculate Unix time for.</param>
+	/// <param name="dto"><see cref="DateTimeOffset"/> to calculate Unix time for.</param>
 	/// <returns>Calculated Unix time.</returns>
 	public static long GetUnixTime(DateTimeOffset dto)
 		=> dto.ToUnixTimeMilliseconds();
 
 	/// <summary>
 	/// Computes a timestamp from a given snowflake.
 	/// </summary>
 	/// <param name="snowflake">Snowflake to compute a timestamp from.</param>
 	/// <returns>Computed timestamp.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static DateTimeOffset GetSnowflakeTime(this ulong snowflake)
 		=> DiscordClient.DiscordEpoch.AddMilliseconds(snowflake >> 22);
 
 	/// <summary>
 	/// Converts this <see cref="Permissions"/> into human-readable format.
 	/// </summary>
 	/// <param name="perm">Permissions enumeration to convert.</param>
 	/// <returns>Human-readable permissions.</returns>
 	public static string ToPermissionString(this Permissions perm)
 	{
 		if (perm == Permissions.None)
 			return PermissionStrings[perm];
 
 		perm &= PermissionMethods.FullPerms;
 
 		var strs = PermissionStrings
 			.Where(xkvp => xkvp.Key != Permissions.None && (perm & xkvp.Key) == xkvp.Key)
 			.Select(xkvp => xkvp.Value);
 
 		return string.Join(", ", strs.OrderBy(xs => xs));
 	}
 
 	/// <summary>
 	/// Checks whether this string contains given characters.
 	/// </summary>
 	/// <param name="str">String to check.</param>
 	/// <param name="characters">Characters to check for.</param>
 	/// <returns>Whether the string contained these characters.</returns>
 	public static bool Contains(this string str, params char[] characters)
 	{
 		foreach (var xc in str)
 			if (characters.Contains(xc))
 				return true;
 
 		return false;
 	}
 
 	/// <summary>
 	/// Logs the task fault.
 	/// </summary>
 	/// <param name="task">The task.</param>
 	/// <param name="logger">The logger.</param>
 	/// <param name="level">The level.</param>
 	/// <param name="eventId">The event id.</param>
 	/// <param name="message">The message.</param>
 	internal static void LogTaskFault(this Task task, ILogger logger, LogLevel level, EventId eventId, string message)
 	{
 		if (task == null)
 			throw new ArgumentNullException(nameof(task));
 
 		if (logger == null)
 			return;
 
 		task.ContinueWith(t => logger.Log(level, eventId, t.Exception, message), TaskContinuationOptions.OnlyOnFaulted);
 	}
 
 	/// <summary>
 	/// Deconstructs the.
 	/// </summary>
 	/// <param name="kvp">The kvp.</param>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	internal static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
 	{
 		key = kvp.Key;
 		value = kvp.Value;
 	}
 }