diff --git a/DisCatSharp.CommandsNext/CommandsNextExtension.cs b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
index 89a21f217..dc519b047 100644
--- a/DisCatSharp.CommandsNext/CommandsNextExtension.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
@@ -1,1083 +1,1083 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Common.Utilities;
 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 CommandsNextConfiguration Config { get; }
         /// <summary>
         /// Gets the help formatter.
         /// </summary>
         private HelpFormatterFactory HelpFormatter { get; }
 
         /// <summary>
         /// Gets the convert generic.
         /// </summary>
         private MethodInfo ConvertGeneric { get; }
         /// <summary>
         /// Gets the user friendly type names.
         /// </summary>
         private Dictionary<Type, string> UserFriendlyTypeNames { get; }
         /// <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()
             };
 
             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"
             };
 
             var ncvt = typeof(NullableConverter<>);
             var nt = typeof(Nullable<>);
             var cvts = this.ArgumentConverters.Keys.ToArray();
             foreach (var xt in cvts)
             {
                 var xti = xt.GetTypeInfo();
                 if (!xti.IsValueType)
                     continue;
 
                 var xcvt = ncvt.MakeGenericType(xt);
                 var xnt = nt.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 = typeof(CommandsNextExtension);
             var ms = t.GetTypeInfo().DeclaredMethods;
             var m = ms.FirstOrDefault(xm => xm.Name == "ConvertArgument" && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPublic);
             this.ConvertGeneric = m;
         }
 
         /// <summary>
         /// Sets the help formatter to use with the default help command.
         /// </summary>
         /// <typeparam name="T">Type of the formatter to use.</typeparam>
         public void SetHelpFormatter<T>() where T : BaseHelpFormatter => this.HelpFormatter.SetFormatterType<T>();
 
         #region DiscordClient Registration
         /// <summary>
         /// DO NOT USE THIS MANUALLY.
         /// </summary>
         /// <param name="client">DO NOT USE THIS MANUALLY.</param>
-        /// <exception cref="InvalidOperationException"/>
+        /// <exception cref="System.InvalidOperationException"/>
         protected internal override void Setup(DiscordClient client)
         {
             if (this.Client != null)
                 throw new InvalidOperationException("What did I tell you?");
 
             this.Client = client;
 
             this._executed = new AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs>("COMMAND_EXECUTED", TimeSpan.Zero, this.Client.EventErrorHandler);
             this._error = new AsyncEvent<CommandsNextExtension, CommandErrorEventArgs>("COMMAND_ERRORED", TimeSpan.Zero, this.Client.EventErrorHandler);
 
             if (this.Config.UseDefaultCommandHandler)
                 this.Client.MessageCreated += this.HandleCommandsAsync;
             else
                 this.Client.Logger.LogWarning(CommandsNextEvents.Misc, "Not attaching default command handler - if this is intentional, you can ignore this message");
 
             if (this.Config.EnableDefaultHelp)
             {
                 this.RegisterCommands(typeof(DefaultHelpModule), null, null, out var tcmds);
 
                 if (this.Config.DefaultHelpChecks != null)
                 {
                     var checks = this.Config.DefaultHelpChecks.ToArray();
 
                     for (var i = 0; i < tcmds.Count; i++)
                         tcmds[i].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.Substring(0, mpos);
             var cnt = e.Message.Content.Substring(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.Substring(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.Substring(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 Dictionary<string, Command> TopLevelCommands { get; set; }
         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.Substring(0, moduleName.Length - 5);
                             else if (moduleName.EndsWith("Module") && moduleName != "Module")
                                 moduleName = moduleName.Substring(0, moduleName.Length - 6);
                             else if (moduleName.EndsWith("Commands") && moduleName != "Commands")
                                 moduleName = moduleName.Substring(0, moduleName.Length - 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.Substring(0, commandName.Length - 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>
         /// Unregisters 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,
                 _attachments = new List<DiscordAttachment>(),
                 _embeds = new List<DiscordEmbed>(),
                 TimestampRaw = now.ToString("yyyy-MM-ddTHH:mm:sszzz"),
                 _reactions = 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._members.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._mentionedUsers = mentionedUsers;
             msg._mentionedRoles = mentionedRoles;
             msg._mentionedChannels = 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>
 #pragma warning disable IDE1006 // Naming Styles
         public async Task<object> ConvertArgument<T>(string value, CommandContext ctx)
 #pragma warning restore IDE1006 // Naming Styles
         {
             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>
 #pragma warning disable IDE1006 // Naming Styles
         public async Task<object> ConvertArgument(string value, CommandContext ctx, Type type)
 #pragma warning restore IDE1006 // Naming Styles
         {
             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>
         /// Unregisters 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>
         /// 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>
         /// Ons the command executed.
         /// </summary>
         /// <param name="e">The e.</param>
         /// <returns>A Task.</returns>
         private Task OnCommandExecuted(CommandExecutionEventArgs e)
             => this._executed.InvokeAsync(this, e);
 
         /// <summary>
         /// Ons the command errored.
         /// </summary>
         /// <param name="e">The e.</param>
         /// <returns>A Task.</returns>
         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 9c8cc3159..55fcd8beb 100644
--- a/DisCatSharp.Common/Attributes/DateTimeFormatAttribute.cs
+++ b/DisCatSharp.Common/Attributes/DateTimeFormatAttribute.cs
@@ -1,133 +1,133 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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;
 
 namespace DisCatSharp.Common.Serialization
 {
     /// <summary>
-    /// Defines the format for string-serialized <see cref="DateTime"/> and <see cref="DateTimeOffset"/> objects.
+    /// Defines the format for string-serialized <see cref="DateTime"/> and <see cref="System.DateTimeOffset"/> objects.
     /// </summary>
     [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
     public sealed class DateTimeFormatAttribute : SerializationAttribute
     {
         /// <summary>
         /// Gets the ISO 8601 format string of "yyyy-MM-ddTHH:mm:ss.fffzzz".
         /// </summary>
         public const string FormatISO8601 = "yyyy-MM-ddTHH:mm:ss.fffzzz";
 
         /// <summary>
         /// Gets the RFC 1123 format string of "R".
         /// </summary>
         public const string FormatRFC1123 = "R";
 
         /// <summary>
         /// Gets the general long format.
         /// </summary>
         public const string FormatLong = "G";
 
         /// <summary>
         /// Gets the general short format.
         /// </summary>
         public const string FormatShort = "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="DateTime"/> and <see cref="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="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="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="CultureInfo.InvariantCulture"/>, with a format string of "G".
         /// </summary>
         InvariantLocaleLong = 4,
 
         /// <summary>
         /// Specifies a format defined by <see cref="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/UnixTimestampAttributes.cs b/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs
index 758145715..1579de6d5 100644
--- a/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs
+++ b/DisCatSharp.Common/Attributes/UnixTimestampAttributes.cs
@@ -1,42 +1,42 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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="DateTime"/> or <see cref="DateTimeOffset"/> will be serialized as Unix timestamp seconds.</para>
+    /// <para>Specifies that this <see cref="DateTime"/> or <see cref="System.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, AllowMultiple = false, Inherited = true)]
     public sealed class UnixSecondsAttribute : SerializationAttribute
     { }
 
     /// <summary>
-    /// <para>Specifies that this <see cref="DateTime"/> or <see cref="DateTimeOffset"/> will be serialized as Unix timestamp milliseconds.</para>
+    /// <para>Specifies that this <see cref="DateTime"/> or <see cref="System.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, AllowMultiple = false, Inherited = true)]
     public sealed class UnixMillisecondsAttribute : SerializationAttribute
     { }
 }
diff --git a/DisCatSharp.Interactivity/Extensions/ChannelExtensions.cs b/DisCatSharp.Interactivity/Extensions/ChannelExtensions.cs
index c5341a108..871d321b6 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.
 //
 // Copyright (c) 2021 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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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'll 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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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'll 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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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'll 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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the channel.</exception>
+        /// <exception cref="System.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">The timeoutoverride.</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 58ed4dec6..1c18425d6 100644
--- a/DisCatSharp.Interactivity/Extensions/ClientExtensions.cs
+++ b/DisCatSharp.Interactivity/Extensions/ClientExtensions.cs
@@ -1,100 +1,100 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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="InvalidOperationException">Thrown if interactivity has already been enabled for the client instance.</exception>
+        /// <exception cref="System.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 1b3a13998..4b3878ae5 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.
 //
 // Copyright (c) 2021 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="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="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="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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown if interactivity is not enabled for the client associated with the message.</exception>
+        /// <exception cref="System.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 45321747d..a49fab9b6 100644
--- a/DisCatSharp.Interactivity/InteractivityExtension.cs
+++ b/DisCatSharp.Interactivity/InteractivityExtension.cs
@@ -1,930 +1,930 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Enums;
 using System.Threading;
 using System.Globalization;
 
 namespace DisCatSharp.Interactivity
 {
     /// <summary>
     /// Extension class for DisCatSharp.Interactivity
     /// </summary>
     public class InteractivityExtension : BaseExtension
     {
 
 #pragma warning disable IDE1006 // Naming Styles
         /// <summary>
         /// Gets the config.
         /// </summary>
         internal InteractivityConfiguration Config { get; }
 
         private EventWaiter<MessageCreateEventArgs> MessageCreatedWaiter;
 
         private EventWaiter<MessageReactionAddEventArgs> MessageReactionAddWaiter;
 
         private EventWaiter<TypingStartEventArgs> TypingStartWaiter;
 
         private EventWaiter<ComponentInteractionCreateEventArgs> ComponentInteractionWaiter;
 
         private ComponentEventWaiter ComponentEventWaiter;
 
         private ReactionCollector ReactionCollector;
 
         private Poller Poller;
 
         private Paginator Paginator;
         private  ComponentPaginator _compPaginator;
 
 #pragma warning restore IDE1006 // Naming Styles
 
         /// <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.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(this.Client, this.Config);
             this.ComponentEventWaiter = new(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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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(message,
                     c =>
                         c.Interaction.Data.ComponentType == ComponentType.Button &&
                         buttons.Any(b => b.CustomId == c.Id), token)).ConfigureAwait(false);
 
             return new(res is null, res);
         }
 
         /// <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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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(message, c => c.Interaction.Data.ComponentType == ComponentType.Button && ids.Contains(c.Id), token))
                 .ConfigureAwait(false);
 
             return new(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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.User == user, token))
                 .ConfigureAwait(false);
 
             return new(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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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="InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
+        /// <exception cref="System.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(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.Id == id, token))
                 .ConfigureAwait(false);
 
             return new(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="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(message, c => c.Interaction.Data.ComponentType is ComponentType.Button && predicate(c), token))
                 .ConfigureAwait(false);
 
             return new(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="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="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(message, c => c.Interaction.Data.ComponentType is ComponentType.Select && predicate(c), token))
                 .ConfigureAwait(false);
 
             return new(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="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="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(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Select && c.Id == id, token))
                 .ConfigureAwait(false);
 
             return new(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="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="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(message, (c) => c.Id == id && c.User == user, token)).ConfigureAwait(false);
 
             return new(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(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.ToArray(), 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">The timeoutoverride.</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.ToArray());
 
             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="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 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(bts);
             if (bhv is PaginationBehaviour.Ignore)
             {
                 bts.SkipLeft.Disable();
                 bts.Left.Disable();
             }
 
             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);
             var 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() { 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 fe1a40d54..4ebea4ce5 100644
--- a/DisCatSharp.Lavalink/LavalinkExtension.cs
+++ b/DisCatSharp.Lavalink/LavalinkExtension.cs
@@ -1,215 +1,215 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.Common.Utilities;
 
 namespace DisCatSharp.Lavalink
 {
     /// <summary>
     /// The lavalink extension.
     /// </summary>
     public sealed class LavalinkExtension : BaseExtension
     {
         /// <summary>
         /// Triggered whenever a node disconnects.
         /// </summary>
         public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> NodeDisconnected
         {
             add { this._nodeDisconnected.Register(value); }
             remove { this._nodeDisconnected.Unregister(value); }
         }
         private AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _nodeDisconnected;
 
         /// <summary>
         /// Gets a dictionary of connected Lavalink nodes for the extension.
         /// </summary>
         public IReadOnlyDictionary<ConnectionEndpoint, LavalinkNodeConnection> ConnectedNodes { get; }
         private readonly ConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection> _connectedNodes = new();
 
         /// <summary>
         /// Creates a new instance of this Lavalink extension.
         /// </summary>
         internal LavalinkExtension()
         {
             this.ConnectedNodes = new ReadOnlyConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection>(this._connectedNodes);
         }
 
         /// <summary>
         /// DO NOT USE THIS MANUALLY.
         /// </summary>
         /// <param name="client">DO NOT USE THIS MANUALLY.</param>
-        /// <exception cref="InvalidOperationException"/>
+        /// <exception cref="System.InvalidOperationException"/>
         protected internal override void Setup(DiscordClient client)
         {
             if (this.Client != null)
                 throw new InvalidOperationException("What did I tell you?");
 
             this.Client = client;
 
             this._nodeDisconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Client.EventErrorHandler);
         }
 
         /// <summary>
         /// Connect to a Lavalink node.
         /// </summary>
         /// <param name="config">Lavalink client configuration.</param>
         /// <returns>The established Lavalink connection.</returns>
         public async Task<LavalinkNodeConnection> ConnectAsync(LavalinkConfiguration config)
         {
             if (this._connectedNodes.ContainsKey(config.SocketEndpoint))
                 return this._connectedNodes[config.SocketEndpoint];
 
             var con = new LavalinkNodeConnection(this.Client, this, config);
             con.NodeDisconnected += this.Con_NodeDisconnected;
             con.Disconnected += this.Con_Disconnected;
             this._connectedNodes[con.NodeEndpoint] = con;
             try
             {
                 await con.StartAsync().ConfigureAwait(false);
             }
             catch
             {
                 this.Con_NodeDisconnected(con);
                 throw;
             }
 
             return con;
         }
 
         /// <summary>
         /// Gets the Lavalink node connection for the specified endpoint.
         /// </summary>
         /// <param name="endpoint">Endpoint at which the node resides.</param>
         /// <returns>Lavalink node connection.</returns>
         public LavalinkNodeConnection GetNodeConnection(ConnectionEndpoint endpoint)
             => this._connectedNodes.ContainsKey(endpoint) ? this._connectedNodes[endpoint] : null;
 
         /// <summary>
         /// Gets a Lavalink node connection based on load balancing and an optional voice region.
         /// </summary>
         /// <param name="region">The region to compare with the node's <see cref="LavalinkConfiguration.Region"/>, if any.</param>
         /// <returns>The least load affected node connection, or null if no nodes are present.</returns>
         public LavalinkNodeConnection GetIdealNodeConnection(DiscordVoiceRegion region = null)
         {
             if (this._connectedNodes.Count <= 1)
                 return this._connectedNodes.Values.FirstOrDefault();
 
             var nodes = this._connectedNodes.Values.ToArray();
 
             if (region != null)
             {
                 var regionPredicate = new Func<LavalinkNodeConnection, bool>(x => x.Region == region);
 
                 if (nodes.Any(regionPredicate))
                     nodes = nodes.Where(regionPredicate).ToArray();
 
                 if (nodes.Count() <= 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._connectedGuilds.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/VoiceNextExtension.cs b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
index cb94f4006..7d5e1ce7d 100644
--- a/DisCatSharp.VoiceNext/VoiceNextExtension.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
@@ -1,261 +1,261 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.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 VoiceNextConfiguration Configuration { get; set; }
 
         /// <summary>
         /// Gets or sets the active connections.
         /// </summary>
         private ConcurrentDictionary<ulong, VoiceNextConnection> ActiveConnections { get; set; }
         /// <summary>
         /// Gets or sets the voice state updates.
         /// </summary>
         private ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> VoiceStateUpdates { get; set; }
         /// <summary>
         /// Gets or sets the voice server updates.
         /// </summary>
         private ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> VoiceServerUpdates { get; set; }
 
         /// <summary>
         /// Gets whether this connection has incoming voice enabled.
         /// </summary>
         public bool IsIncomingEnabled { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="VoiceNextExtension"/> class.
         /// </summary>
         /// <param name="config">The config.</param>
         internal VoiceNextExtension(VoiceNextConfiguration config)
         {
             this.Configuration = new VoiceNextConfiguration(config);
             this.IsIncomingEnabled = config.EnableIncoming;
 
             this.ActiveConnections = new ConcurrentDictionary<ulong, VoiceNextConnection>();
             this.VoiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
             this.VoiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
         }
 
         /// <summary>
         /// DO NOT USE THIS MANUALLY.
         /// </summary>
         /// <param name="client">DO NOT USE THIS MANUALLY.</param>
-        /// <exception cref="InvalidOperationException"/>
+        /// <exception cref="System.InvalidOperationException"/>
         protected internal override void Setup(DiscordClient client)
         {
             if (this.Client != null)
                 throw new InvalidOperationException("What did I tell you?");
 
             this.Client = client;
 
             this.Client.VoiceStateUpdated += this.Client_VoiceStateUpdate;
             this.Client.VoiceServerUpdated += this.Client_VoiceServerUpdate;
         }
 
         /// <summary>
         /// Create a VoiceNext connection for the specified channel.
         /// </summary>
         /// <param name="channel">Channel to connect to.</param>
         /// <returns>VoiceNext connection for this channel.</returns>
         public async Task<VoiceNextConnection> ConnectAsync(DiscordChannel channel)
         {
             if (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage)
                 throw new ArgumentException(nameof(channel), "Invalid channel specified; needs to be voice or stage channel");
 
             if (channel.Guild == null)
                 throw new ArgumentException(nameof(channel), "Invalid channel specified; needs to be guild 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.Substring(0, epi);
                     epp = int.Parse(eps.Substring(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/DiscordClient.cs b/DisCatSharp/Clients/DiscordClient.cs
index c2a8461a7..2b2007d39 100644
--- a/DisCatSharp/Clients/DiscordClient.cs
+++ b/DisCatSharp/Clients/DiscordClient.cs
@@ -1,1314 +1,1314 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using DisCatSharp.Common.Utilities;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
 using DisCatSharp.Enums;
 using System.Globalization;
 
 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 = null;
 
         /// <summary>
         /// Gets the connection lock.
         /// </summary>
         private ManualResetEventSlim ConnectionLock { get; } = new ManualResetEventSlim(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> _guilds = new();
 
         /// <summary>
         /// Gets the WS 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> _presences = 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> _embeddedActivities = 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._guilds);
         }
 
         /// <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._guilds.Clear();
 
             this._presencesLazy = new Lazy<IReadOnlyDictionary<ulong, DiscordPresence>>(() => new ReadOnlyDictionary<ulong, DiscordPresence>(this._presences));
             this._embeddedActivitiesLazy = new Lazy<IReadOnlyDictionary<string, DiscordActivity>>(() => new ReadOnlyDictionary<string, DiscordActivity>(this._embeddedActivities));
         }
 
         #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">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>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task ConnectAsync(DiscordActivity activity = null, UserStatus? status = null, DateTimeOffset? idlesince = null)
         {
             // Check if connection lock is already set, and set it if it isn't
             if (!this.ConnectionLock.Wait(0))
                 throw new InvalidOperationException("This client is already connected.");
             this.ConnectionLock.Set();
 
             var w = 7500;
             var i = 5;
             var s = false;
             Exception cex = null;
 
             if (activity == null && status == null && idlesince == null)
                 this._status = null;
             else
             {
                 var since_unix = idlesince != null ? (long?)Utilities.GetUnixTime(idlesince.Value) : null;
                 this._status = new StatusUpdate()
                 {
                     Activity = new TransportActivity(activity),
                     Status = status ?? UserStatus.Online,
                     IdleSince = since_unix,
                     IsAFK = idlesince != null,
                     _activity = 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">If true, start new session.</param>
         public Task ReconnectAsync(bool startNewSession = false)
             => this.InternalReconnectAsync(startNewSession, code: startNewSession ? 1000 : 4002);
 
         /// <summary>
         /// Disconnects from the gateway.
         /// </summary>
         /// <returns></returns>
         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 false).</param>
         /// <returns>The requested user.</returns>
-        /// <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="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordUser> GetUserAsync(ulong userId, bool fetch = false)
         {
             if (this.TryGetCachedUserInternal(userId, out var usr))
                 return usr;
             else if (!fetch)
                 return new DiscordUser { Id = userId, Discord = this };
 
             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._bannerColor = usr._bannerColor;
                 return old;
             });
 
             return usr;
         }
 
         /// <summary>
         /// Gets a channel.
         /// </summary>
         /// <param name="id">The id of the channel to get.</param>
         /// <returns>The requested channel.</returns>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordChannel> GetChannelAsync(ulong id)
             => this.InternalGetCachedChannel(id) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
         /// <summary>
         /// Gets a thread.
         /// </summary>
         /// <param name="id">The id of the thread to get.</param>
         /// <returns>The requested thread.</returns>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordThreadChannel> GetThreadAsync(ulong id)
             => this.InternalGetCachedThread(id) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
         /// <summary>
         /// Sends a normal message.
         /// </summary>
         /// <param name="channel">Channel to send to.</param>
         /// <param name="content">Message content to send.</param>
         /// <returns>The message that was sent.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content)
             => this.ApiClient.CreateMessageAsync(channel.Id, content, embeds: null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
         /// <summary>
         /// Sends a message with an embed.
         /// </summary>
         /// <param name="channel">Channel to send to.</param>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The message that was sent.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordEmbed embed)
             => this.ApiClient.CreateMessageAsync(channel.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
         /// <summary>
         /// Sends a message with content and an embed.
         /// </summary>
         /// <param name="channel">Channel to send to.</param>
         /// <param name="content">Message content to send.</param>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The message that was sent.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content, DiscordEmbed embed)
             => this.ApiClient.CreateMessageAsync(channel.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
         /// <summary>
         /// Sends a message with the <see cref="DiscordMessageBuilder"/>.
         /// </summary>
         /// <param name="channel">Channel to send the message to.</param>
         /// <param name="builder">The message builder.</param>
         /// <returns>The message that was sent.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordMessageBuilder builder)
             => this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
         /// <summary>
         /// Sends a message with an <see cref="Action{DiscordMessageBuilder}"/>.
         /// </summary>
         /// <param name="channel">Channel to send the message to.</param>
         /// <param name="action">The message builder.</param>
         /// <returns>The message that was sent.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
 
             return this.ApiClient.CreateMessageAsync(channel.Id, builder);
         }
 
         /// <summary>
         /// Creates a guild. This requires the bot to be in less than 10 guilds total.
         /// </summary>
         /// <param name="name">Name of the guild.</param>
         /// <param name="region">Voice region of the guild.</param>
         /// <param name="icon">Stream containing the icon for the guild.</param>
         /// <param name="verificationLevel">Verification level for the guild.</param>
         /// <param name="defaultMessageNotifications">Default message notification settings for the guild.</param>
         /// <param name="systemChannelFlags">System channel flags fopr the guild.</param>
         /// <returns>The created guild.</returns>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuild> CreateGuildAsync(string name, string region = null, Optional<Stream> icon = default, VerificationLevel? verificationLevel = null,
             DefaultMessageNotifications? defaultMessageNotifications = null, SystemChannelFlags? systemChannelFlags = null)
         {
             var iconb64 = Optional.FromNoValue<string>();
             if (icon.HasValue && icon.Value != null)
                 using (var imgtool = new ImageTool(icon.Value))
                     iconb64 = imgtool.GetBase64();
             else if (icon.HasValue)
                 iconb64 = null;
 
             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="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuild> CreateGuildFromTemplateAsync(string code, string name, Optional<Stream> icon = default)
         {
             var iconb64 = Optional.FromNoValue<string>();
             if (icon.HasValue && icon.Value != null)
                 using (var imgtool = new ImageTool(icon.Value))
                     iconb64 = imgtool.GetBase64();
             else if (icon.HasValue)
                 iconb64 = null;
 
             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 addditional headers.</param>
         /// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
-        /// <exception cref="NotFoundException">Thrown when the ressource 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the ressource does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <returns>A awaitable RestResponse</returns>
         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="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null)
         {
             if (this._guilds.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._channels[channel.Id] = channel;
 
             return guild;
         }
 
         /// <summary>
         /// Gets a guild preview.
         /// </summary>
         /// <param name="id">The guild ID.</param>
         /// <returns></returns>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
             => this.ApiClient.GetGuildPreviewAsync(id);
 
         /// <summary>
         /// Gets an invite.
         /// </summary>
         /// <param name="code">The invite code.</param>
         /// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
         /// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
         /// <param name="scheduledEventId">The scheduled event id.</param>
         /// <returns>The requested Invite.</returns>
-        /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the invite does not exists.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
             => this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
         /// <summary>
         /// Gets a list of connections.
         /// </summary>
-        /// <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="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordConnection>> GetConnectionsAsync()
             => this.ApiClient.GetUsersConnectionsAsync();
 
         /// <summary>
         /// Gets a sticker.
         /// </summary>
         /// <returns>The requested sticker.</returns>
         /// <param name="id">The id of the sticker.</param>
-        /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the sticker does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordSticker> GetStickerAsync(ulong id)
             => this.ApiClient.GetStickerAsync(id);
 
 
         /// <summary>
         /// Gets all nitro sticker packs.
         /// </summary>
         /// <returns>List of sticker packs.</returns>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
             => this.ApiClient.GetStickerPacksAsync();
 
 
         /// <summary>
         /// Gets the In-App OAuth Url.
         /// </summary>
         /// <param name="scopes">Defaults to <see cref="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.FULL_PERMS;
             // 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="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordWebhook> GetWebhookAsync(ulong id)
             => this.ApiClient.GetWebhookAsync(id);
 
         /// <summary>
         /// Gets a webhook.
         /// </summary>
         /// <param name="id">The target webhook id.</param>
         /// <param name="token">The target webhook token.</param>
         /// <returns>The requested webhook.</returns>
-        /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
             => this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
         /// <summary>
         /// Updates current user's activity and status.
         /// </summary>
         /// <param name="activity">Activity to set.</param>
         /// <param name="userStatus">Status of the user.</param>
         /// <param name="idleSince">Since when is the client performing the specified activity.</param>
         /// <returns></returns>
         public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
             => this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
         /// <summary>
         /// Edits current user.
         /// </summary>
         /// <param name="username">New username.</param>
         /// <param name="avatar">New avatar.</param>
         /// <returns>The modified user.</returns>
-        /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordUser> UpdateCurrentUserAsync(string username = null, Optional<Stream> avatar = default)
         {
             var av64 = Optional.FromNoValue<string>();
             if (avatar.HasValue && avatar.Value != null)
                 using (var imgtool = new ImageTool(avatar.Value))
                     av64 = imgtool.GetBase64();
             else if (avatar.HasValue)
                 av64 = null;
 
             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="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> GetTemplateAsync(string code)
             => this.ApiClient.GetTemplateAsync(code);
 
         /// <summary>
         /// Gets all the global application commands for this application.
         /// </summary>
         /// <returns>A list of global application commands.</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync() =>
             this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id);
 
         /// <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.DefaultPermission).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>
         /// <returns>A list of application commands in the guild.</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId) =>
             this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId);
 
         /// <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.DefaultPermission).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.GetApplicationCommandPermissionAsync(this.CurrentApplication.Id, guildId, commandId);
 
         /// <summary>
         /// Overwrites the existing permissions for a application command in a guild. New permissions are automatically created and missing permissions are deleted.
         /// A command takes up to 10 permission overwrites.
         /// </summary>
         /// <param name="guildId">The id of the guild.</param>
         /// <param name="commandId">The id of the command.</param>
         /// <param name="permissions">List of permissions.</param>
         public Task<DiscordGuildApplicationCommandPermission> OverwriteGuildApplicationCommandPermissionsAsync(ulong guildId, ulong commandId, IEnumerable<DiscordApplicationCommandPermission> permissions) =>
             this.ApiClient.OverwriteGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId, commandId, permissions);
 
         /// <summary>
         /// Overwrites the existing application command permissions in a guild. New permissions are automatically created and missing permissions are deleted.
         /// Each command takes up to 10 permission overwrites.
         /// </summary>
         /// <param name="guildId">The id of the guild.</param>
         /// <param name="permissionsOverwrites">The list of permissions to overwrite with.</param>
         public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordGuildApplicationCommandPermission> permissionsOverwrites) =>
             this.ApiClient.BulkOverwriteApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId, permissionsOverwrites);
         #endregion
 
         #region Internal Caching Methods
         /// <summary>
         /// Gets the internal chached threads.
         /// </summary>
         /// <param name="threadId">The target thread id.</param>
         /// <returns>The requested thread.</returns>
         internal DiscordThreadChannel InternalGetCachedThread(ulong threadId)
         {
             foreach (var guild in this.Guilds.Values)
                 if (guild.Threads.TryGetValue(threadId, out var foundThread))
                     return foundThread;
 
             return null;
         }
 
 
         /// <summary>
         /// Gets the internal chached scheduled event.
         /// </summary>
         /// <param name="scheduledEventId">The target scheduled event id.</param>
         /// <returns>The requested scheduled event.</returns>
         internal DiscordScheduledEvent InternalGetCachedScheduledEvent(ulong scheduledEventId)
         {
             foreach (var guild in this.Guilds.Values)
                 if (guild.ScheduledEvents.TryGetValue(scheduledEventId, out var foundScheduledEvent))
                     return foundScheduledEvent;
 
             return null;
         }
 
         /// <summary>
         /// Gets the internal chached channel.
         /// </summary>
         /// <param name="channelId">The target channel id.</param>
         /// <returns>The requested channel.</returns>
         internal DiscordChannel InternalGetCachedChannel(ulong channelId)
         {
             foreach (var guild in this.Guilds.Values)
                 if (guild.Channels.TryGetValue(channelId, out var foundChannel))
                     return foundChannel;
 
             return null;
         }
 
         /// <summary>
         /// Gets the internal chached guild.
         /// </summary>
         /// <param name="guildId">The target guild id.</param>
         /// <returns>The requested guild.</returns>
         internal DiscordGuild InternalGetCachedGuild(ulong? guildId)
         {
             if (this._guilds != null && guildId.HasValue)
             {
                 if (this._guilds.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._scheduledEvents.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;
                         return old;
                     });
 
                     usr = new DiscordMember(mbr) { Discord = this, _guild_id = 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?._members.TryGetValue(usr.Id, out member) == false)
                     {
                         if (intents.HasIntent(DiscordIntents.GuildMembers) || this.Configuration.AlwaysCacheMembers) // member can be updated by events, so cache it
                         {
                             guild._members.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._members.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;
                     return old;
                 });
             }
 
             return usr;
         }
 
         /// <summary>
         /// Updates the cached 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._scheduledEvents.Clear();
 
                 foreach (var xj in rawEvents)
                 {
                     var xtm = xj.ToDiscordObject<DiscordScheduledEvent>();
 
                     xtm.Discord = this;
 
                     guild._scheduledEvents[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._guilds.ContainsKey(newGuild.Id))
                 this._guilds[newGuild.Id] = newGuild;
 
             var guild = this._guilds[newGuild.Id];
 
             if (newGuild._channels != null && newGuild._channels.Count > 0)
             {
                 foreach (var channel in newGuild._channels.Values)
                 {
                     if (guild._channels.TryGetValue(channel.Id, out _)) continue;
 
                     foreach (var overwrite in channel._permissionOverwrites)
                     {
                         overwrite.Discord = this;
                         overwrite._channel_id = channel.Id;
                     }
 
                     guild._channels[channel.Id] = channel;
                 }
             }
 
             if (newGuild._threads != null && newGuild._threads.Count > 0)
             {
                 foreach (var thread in newGuild._threads.Values)
                 {
                     if (guild._threads.TryGetValue(thread.Id, out _)) continue;
 
                     guild._threads[thread.Id] = thread;
                 }
             }
 
             if (newGuild._scheduledEvents != null && newGuild._scheduledEvents.Count > 0)
             {
                 foreach (var s_event in newGuild._scheduledEvents.Values)
                 {
                     if (guild._scheduledEvents.TryGetValue(s_event.Id, out _)) continue;
 
                     guild._scheduledEvents[s_event.Id] = s_event;
                 }
             }
 
             foreach (var newEmoji in newGuild._emojis.Values)
                 _ = guild._emojis.GetOrAdd(newEmoji.Id, _ => newEmoji);
 
             foreach (var newSticker in newGuild._stickers.Values)
                 _ = guild._stickers.GetOrAdd(newSticker.Id, _ => newSticker);
 
             foreach (var newStageInstance in newGuild._stageInstances.Values)
                 _ = guild._stageInstances.GetOrAdd(newStageInstance.Id, _ => newStageInstance);
 
             if (rawMembers != null)
             {
                 guild._members.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._members[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, _guild_id = guild.Id };
                 }
             }
 
             foreach (var role in newGuild._roles.Values)
             {
                 if (guild._roles.TryGetValue(role.Id, out _)) continue;
 
                 role._guild_id = guild.Id;
                 guild._roles[role.Id] = role;
             }
 
             guild.Name = newGuild.Name;
             guild.AfkChannelId = newGuild.AfkChannelId;
             guild.AfkTimeout = newGuild.AfkTimeout;
             guild.DefaultMessageNotifications = newGuild.DefaultMessageNotifications;
             guild.RawFeatures = newGuild.RawFeatures;
             guild.IconHash = newGuild.IconHash;
             guild.MfaLevel = newGuild.MfaLevel;
             guild.OwnerId = newGuild.OwnerId;
             guild.VoiceRegionId = newGuild.VoiceRegionId;
             guild.SplashHash = newGuild.SplashHash;
             guild.VerificationLevel = newGuild.VerificationLevel;
             guild.WidgetEnabled = newGuild.WidgetEnabled;
             guild.WidgetChannelId = newGuild.WidgetChannelId;
             guild.ExplicitContentFilter = newGuild.ExplicitContentFilter;
             guild.PremiumTier = newGuild.PremiumTier;
             guild.PremiumSubscriptionCount = newGuild.PremiumSubscriptionCount;
             guild.PremiumProgressBarEnabled = newGuild.PremiumProgressBarEnabled;
             guild.BannerHash = newGuild.BannerHash;
             guild.Description = newGuild.Description;
             guild.VanityUrlCode = newGuild.VanityUrlCode;
             guild.SystemChannelId = newGuild.SystemChannelId;
             guild.SystemChannelFlags = newGuild.SystemChannelFlags;
             guild.DiscoverySplashHash = newGuild.DiscoverySplashHash;
             guild.MaxMembers = newGuild.MaxMembers;
             guild.MaxPresences = newGuild.MaxPresences;
             guild.ApproximateMemberCount = newGuild.ApproximateMemberCount;
             guild.ApproximatePresenceCount = newGuild.ApproximatePresenceCount;
             guild.MaxVideoChannelUsers = newGuild.MaxVideoChannelUsers;
             guild.PreferredLocale = newGuild.PreferredLocale;
             guild.RulesChannelId = newGuild.RulesChannelId;
             guild.PublicUpdatesChannelId = newGuild.PublicUpdatesChannelId;
             guild.ApplicationId = newGuild.ApplicationId;
 
             // fields not sent for update:
             // - guild.Channels
             // - voice states
             // - guild.JoinedAt = new_guild.JoinedAt;
             // - guild.Large = new_guild.Large;
             // - guild.MemberCount = Math.Max(new_guild.MemberCount, guild._members.Count);
             // - guild.Unavailable = new_guild.Unavailable;
         }
 
         /// <summary>
         /// Populates the message reactions and cache.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <param name="author">The author.</param>
         /// <param name="member">The member.</param>
         private void PopulateMessageReactionsAndCache(DiscordMessage message, TransportUser author, TransportMember member)
         {
             var guild = message.Channel?.Guild ?? this.InternalGetCachedGuild(message.GuildId);
 
             this.UpdateMessage(message, author, guild, member);
 
             if (message._reactions == null)
                 message._reactions = new List<DiscordReaction>();
             foreach (var xr in message._reactions)
                 xr.Emoji.Discord = this;
 
             if (this.Configuration.MessageCacheSize > 0 && message.Channel != null)
                 this.MessageCache?.Add(message);
         }
 
 
         #endregion
 
         #region Disposal
 
         ~DiscordClient()
         {
             this.Dispose();
         }
 
 
         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._guilds = null;
             this._heartbeatTask = null;
         }
 
         #endregion
     }
 }
diff --git a/DisCatSharp/Clients/DiscordShardedClient.cs b/DisCatSharp/Clients/DiscordShardedClient.cs
index 54ae595b2..444e951bc 100644
--- a/DisCatSharp/Clients/DiscordShardedClient.cs
+++ b/DisCatSharp/Clients/DiscordShardedClient.cs
@@ -1,745 +1,745 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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; }
 
         /// <summary>
         /// Gets the library team.
         /// </summary>
         public DisCatSharpTeam LibraryDeveloperTeam
             => this.GetShard(0).LibraryDeveloperTeam;
 
         /// <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 DiscordConfiguration Configuration { get; }
 
         /// <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;
 
         private readonly ConcurrentDictionary<int, DiscordClient> _shards = new();
         private Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> _voiceRegionsLazy;
         private bool _isStarted;
         private readonly bool _manuallySharding;
 
         #endregion
 
         #region Constructor
 
         /// <summary>
         /// Initializes new auto-sharding Discord client.
         /// </summary>
         /// <param name="config">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="AggregateException"></exception>
-        /// <exception cref="InvalidOperationException"></exception>
+        /// <exception cref="System.AggregateException"></exception>
+        /// <exception cref="System.InvalidOperationException"></exception>
         /// <returns></returns>
         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 of all shards.
         /// </summary>
         /// <returns></returns>
-        /// <exception cref="InvalidOperationException"></exception>
+        /// <exception cref="System.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 <see langword="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 <see langword="null"/> if the shard was not found for the guild.</returns>
         public DiscordClient GetShard(DiscordGuild guild)
             => this.GetShard(guild.Id);
 
         /// <summary>
         /// Updates playing statuses on all shards.
         /// </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>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);
         }
 
         #endregion
 
         #region Internal Methods
 
         /// <summary>
         /// Initializes the shards async.
         /// </summary>
         /// <returns>A Task.</returns>
         internal async Task<int> InitializeShardsAsync()
         {
             if (this._shards.Count != 0)
                 return this._shards.Count;
 
             this.GatewayInfo = await this.GetGatewayInfoAsync().ConfigureAwait(false);
             var shardc = this.Configuration.ShardCount == 1 ? this.GatewayInfo.ShardCount : this.Configuration.ShardCount;
             var lf = new ShardedLoggerFactory(this.Logger);
             for (var i = 0; i < shardc; i++)
             {
                 var cfg = new DiscordConfiguration(this.Configuration)
                 {
                     ShardId = i,
                     ShardCount = shardc,
                     LoggerFactory = lf
                 };
 
                 var client = new DiscordClient(cfg);
                 if (!this._shards.TryAdd(i, client))
                     throw new InvalidOperationException("Could not initialize shards.");
             }
 
             return shardc;
         }
 
         #endregion
 
         #region Private Methods/Version Property
 
         /// <summary>
         /// Gets the gateway info async.
         /// </summary>
         /// <returns>A Task.</returns>
         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));
             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.resetAfter -= (int)timer.ElapsedMilliseconds;
             info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.resetAfter);
 
             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 retry_after_raw))
                         waitInterval = int.Parse(retry_after_raw, 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}");
                 }
             }
         }
 
 
         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;
         });
 
         private readonly string _botLibrary = "DisCatSharp";
 
         #endregion
 
         #region Private Connection Methods
 
         /// <summary>
         /// Connects the shard async.
         /// </summary>
         /// <param name="i">The i.</param>
         /// <returns>A Task.</returns>
         private async Task ConnectShardAsync(int i)
         {
             if (!this._shards.TryGetValue(i, out var client))
                 throw new Exception($"Could not initialize shard {i}.");
 
             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._voice_regions_lazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(client.InternalVoiceRegions));
             }
 
             this.HookEventHandlers(client);
 
             client._isShard = true;
             await client.ConnectAsync().ConfigureAwait(false);
             this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booted shard {0}.", i);
 
             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>
         /// Internals the stop async.
         /// </summary>
         /// <param name="enableLogger">If true, enable logger.</param>
         /// <returns>A Task.</returns>
         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>
         /// Internals the setup.
         /// </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);
         }
 
         /// <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;
         }
 
         /// <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;
         }
 
         /// <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._guilds.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 e1cf20570..a7d6f85b5 100644
--- a/DisCatSharp/DiscordConfiguration.cs
+++ b/DisCatSharp/DiscordConfiguration.cs
@@ -1,275 +1,275 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.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="LogLevel.Information"/> is ok for most uses.</para>
         /// </summary>
         public LogLevel MinimumLogLevel { internal get; set; } = LogLevel.Information;
 
         /// <summary>
         /// Overwrites the api version.
         /// Defaults to 9.
         /// </summary>
         public string ApiVersion { internal get; set; } = "9";
 
         /// <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; } = 0;
 
         /// <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; } = null;
 
         /// <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; } = false;
 
         /// <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="WebSocketClient.CreateNew(IWebProxy, IServiceProvider)"/> and equivalents on other implementations to switch out client implementations.</para>
         /// <para>Defaults to <see cref="WebSocketClient.CreateNew(IWebProxy, IServiceProvider)"/>.</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>
+        /// <para>Use <see cref="DisCatSharp.Net.Udp.DCSUdpClient.CreateNew"/> and equivalents on other implementations to switch out client implementations.</para>
+        /// <para>Defaults to <see cref="DisCatSharp.Net.Udp.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="ILoggerFactory"/> instance.</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; } = null;
 
         /// <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; } = false;
-
+        
         /// <summary>
         /// <para>Use canary.</para>
         /// <para>Defaults to false.</para>
         /// </summary>
         public bool UseCanary { internal get; set; } = false;
 
         /// <summary>
         /// <para>Refresh full guild channel cache.</para>
         /// <para>Defaults to false.</para>
         /// </summary>
         public bool AutoRefreshChannelCache { internal get; set; } = false;
 
         /// <summary>
         /// <para>Do not use, this is meant for DisCatSharp Devs.</para>
         /// <para>Defaults to null.</para>
         /// </summary>
         public string Override { internal get; set; } = null;
 
         /// <summary>
         /// <para>Sets the service provider.</para>
         /// <para>This allows passing data around without resorting to static members.</para>
         /// <para>Defaults to null.</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.AutoRefreshChannelCache = other.AutoRefreshChannelCache;
             this.ApiVersion = other.ApiVersion;
             this.ServiceProvider = other.ServiceProvider;
             this.Override = other.Override;
         }
     }
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index 721a041ac..02b30a24f 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1403 +1,1403 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 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 this channels's banner hash, when applicable.
         /// </summary>
         [JsonProperty("banner")]
         public string BannerHash { get; internal set; }
 
         /// <summary>
         /// Gets this channels's banner in url form.
         /// </summary>
         [JsonIgnore]
         public string BannerUrl
             => !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.CHANNELS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
         /// <summary>
         /// Gets the position of this channel.
         /// </summary>
         [JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
         public int Position { get; internal set; }
 
         /// <summary>
         /// Gets the maximum available position to move the channel to.
         /// This can contain outdated informations.
         /// </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).ToArray().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).ToArray().Last().Position
                         : channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().Last().Position
                 : channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().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).ToArray().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).ToArray().First().Position
                         : channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().First().Position
                 : channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().First().Position;
         }
 
         /// <summary>
         /// Gets whether this channel is a DM channel.
         /// </summary>
         [JsonIgnore]
         public bool IsPrivate
             => this.Type == ChannelType.Private || this.Type == ChannelType.Group;
 
         /// <summary>
         /// Gets whether this channel is a channel category.
         /// </summary>
         [JsonIgnore]
         public bool IsCategory
             => this.Type == ChannelType.Category;
 
         /// <summary>
         /// Gets whether this channel is a stage channel.
         /// </summary>
         [JsonIgnore]
         public bool IsStage
             => this.Type == ChannelType.Stage;
 
         /// <summary>
         /// Gets the guild to which this channel belongs.
         /// </summary>
         [JsonIgnore]
         public DiscordGuild Guild
             => this.GuildId.HasValue && this.Discord.Guilds.TryGetValue(this.GuildId.Value, out var guild) ? guild : null;
 
         /// <summary>
         /// Gets a collection of permission overwrites for this channel.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordOverwrite> PermissionOverwrites
             => this._permissionOverwritesLazy.Value;
 
         [JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordOverwrite> _permissionOverwrites = new();
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordOverwrite>> _permissionOverwritesLazy;
 
         /// <summary>
         /// Gets the channel's topic. This is applicable to text channels only.
         /// </summary>
         [JsonProperty("topic", NullValueHandling = NullValueHandling.Ignore)]
         public string Topic { get; internal set; }
 
         /// <summary>
         /// Gets the ID of the last message sent in this channel. This is applicable to text channels only.
         /// </summary>
         [JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? LastMessageId { get; internal set; }
 
         /// <summary>
         /// Gets this channel's bitrate. This is applicable to voice channels only.
         /// </summary>
         [JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
         public int? Bitrate { get; internal set; }
 
         /// <summary>
         /// Gets this channel's user limit. This is applicable to voice channels only.
         /// </summary>
         [JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
         public int? UserLimit { get; internal set; }
 
         /// <summary>
         /// <para>Gets the slow mode delay configured for this channel.</para>
         /// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slow mode.</para>
         /// </summary>
         [JsonProperty("rate_limit_per_user")]
         public int? PerUserRateLimit { get; internal set; }
 
         /// <summary>
         /// Gets this channel's video quality mode. This is applicable to voice channels only.
         /// </summary>
         [JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
         public VideoQualityMode? QualityMode { get; internal set; }
 
         /// <summary>
         /// 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
         {
             get
             {
                 return !this.IsCategory
                     ? throw new ArgumentException("Only channel categories contain children.")
                     : this.Guild._channels.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
         {
             get
             {
                 return 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")]
         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._permissionOverwrites));
         }
 
         #region Methods
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(string content)
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="builder">The builder with all the items to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
             => this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="action">The builder with all the items to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
 
 
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
         }
 
         /// <summary>
         /// Deletes a guild channel
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAsync(string reason = null)
             => this.Discord.ApiClient.DeleteChannelAsync(this.Id, reason);
 
         /// <summary>
         /// Clones this channel. This operation will create a channel with identical settings to this one. Note that this will not copy messages.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>Newly-created channel.</returns>
         /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordChannel> CloneAsync(string reason = null)
         {
             if (this.Guild == null)
                 throw new InvalidOperationException("Non-guild channels cannot be cloned.");
 
             var ovrs = new List<DiscordOverwriteBuilder>();
             foreach (var ovr in this._permissionOverwrites)
 #pragma warning disable CS0618 // Type or member is obsolete
                 ovrs.Add(await new DiscordOverwriteBuilder().FromAsync(ovr).ConfigureAwait(false));
 #pragma warning restore CS0618 // Type or member is obsolete
 
             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.IsWriteable())
             {
                 perUserRateLimit = Optional.FromNoValue<int?>();
             }
 
             return await this.Guild.CreateChannelAsync(this.Name, this.Type, this.Parent, this.Topic, bitrate, userLimit, ovrs, this.IsNSFW, perUserRateLimit, this.QualityMode, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a specific message
         /// </summary>
         /// <param name="id">The id of the message</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> GetMessageAsync(ulong id)
         {
             return this.Discord.Configuration.MessageCacheSize > 0
                 && this.Discord is DiscordClient dc
                 && dc.MessageCache != null
                 && dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
                 ? msg
                 : await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Modifies the current channel.
         /// </summary>
         /// <param name="action">Action to perform on this channel</param>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ModifyAsync(Action<ChannelEditModel> action)
         {
             var mdl = new ChannelEditModel();
             action(mdl);
 
             if (mdl.DefaultAutoArchiveDuration.HasValue)
             {
                 if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value))
                     throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
             }
             if (mdl.Banner.HasValue)
             {
                 if (!this.Guild.Features.CanSetChannelBanner)
                     throw new NotSupportedException($"Cannot modify Banner. Guild needs boost tier three.");
             }
 
             var bannerb64 = Optional.FromNoValue<string>();
             if (mdl.Banner.HasValue && mdl.Banner.Value != null)
                 using (var imgtool = new ImageTool(mdl.Banner.Value))
                     bannerb64 = imgtool.GetBase64();
             else if (mdl.Banner.HasValue)
                 bannerb64 = null;
 
             return this.Discord.ApiClient.ModifyChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Nsfw,
                 mdl.Parent.HasValue ? mdl.Parent.Value?.Id : default(Optional<ulong?>), mdl.Bitrate, mdl.Userlimit, mdl.PerUserRateLimit, mdl.RtcRegion.IfPresent(r => r?.Id),
                 mdl.QualityMode, mdl.DefaultAutoArchiveDuration, mdl.Type, mdl.PermissionOverwrites, bannerb64, mdl.AuditLogReason);
         }
 
         /// <summary>
         /// Updates the channel position when it doesn't have a category.
         /// 
         /// Use <see cref="ModifyParentAsync"/> for moving to other categories.
         /// Use <see cref="RemoveParentAsync"/> to move out of a category.
         /// Use <see cref="ModifyPositionInCategoryAsync"/> for moving within a category.
         /// </summary>
         /// <param name="position">Position the channel should be moved to.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ModifyPositionAsync(int position, string reason = null)
         {
             if (this.Guild == null)
                 throw new ArgumentException("Cannot modify order of non-guild channels.");
             if (!this.IsMovable())
                 throw new NotSupportedException("You can't move this type of channel in categories.");
             if (this.ParentId != null)
                 throw new ArgumentException("Cannot modify order of channels within a category. Use ModifyPositionInCategoryAsync instead.");
 
             var chns = this.Guild._channels.Values.Where(xc => xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray();
             var pmds = new RestGuildChannelReorderPayload[chns.Length];
             for (var i = 0; i < chns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelReorderPayload
                 {
                     ChannelId = chns[i].Id,
                 };
 
                 pmds[i].Position = chns[i].Id == this.Id ? position : chns[i].Position >= position ? chns[i].Position + 1 : chns[i].Position;
             }
 
             return this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason);
         }
 
         /// <summary>
         /// Updates the channel position within it's own category.
         ///
         /// Use <see cref="ModifyParentAsync"/> for moving to other categories.
         /// Use <see cref="RemoveParentAsync"/> to move out of a category.
         /// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
         /// </summary>
         /// <param name="position">The position.</param>
         /// <param name="reason">The reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="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="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.ParentId == null)
             //    throw new ArgumentException("You can call this function only on channels in categories.");
 
             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 = new RestGuildChannelReorderPayload[ochns.Length];
             for (var i = 0; i < ochns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelReorderPayload
                 {
                     ChannelId = ochns[i].Id,
                 };
 
                 if (ochns[i].Id == this.Id)
                 {
                     pmds[i].Position = position;
                 }
                 else
                 {
                     if (isUp)
                     {
                         if (ochns[i].Position <= position && ochns[i].Position > this.Position)
                         {
                             pmds[i].Position = ochns[i].Position - 1;
                         }
                         else if (ochns[i].Position < this.Position || ochns[i].Position > position)
                         {
                             pmds[i].Position = ochns[i].Position;
                         }
                     }
                     else
                     {
                         if (ochns[i].Position >= position && ochns[i].Position < this.Position)
                         {
                             pmds[i].Position = ochns[i].Position + 1;
                         }
                         else if (ochns[i].Position > this.Position || ochns[i].Position < position)
                         {
                             pmds[i].Position = ochns[i].Position;
                         }
                     }
                 }
             }
 
             await this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Internaly refreshes the channel list.
         /// </summary>
         private async Task<IReadOnlyList<DiscordChannel>> InternalRefreshChannelsAsync()
         {
             await this.RefreshPositionsAsync();
             return this.Guild.Channels.Values.ToList().AsReadOnly();
         }
 
         /// <summary>
         /// Refreshes the positions.
         /// </summary>
         public async Task RefreshPositionsAsync()
         {
             var channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Guild.Id);
             this.Guild._channels.Clear();
             foreach (var channel in channels.ToList())
             {
                 channel.Discord = this.Discord;
                 foreach (var xo in channel._permissionOverwrites)
                 {
                     xo.Discord = this.Discord;
                     xo._channel_id = channel.Id;
                 }
                 this.Guild._channels[channel.Id] = channel;
             }
         }
 
         /// <summary>
         /// Updates the channel position within it's own category.
         /// Valid modes: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up.
         /// 
         /// Use <see cref="ModifyParentAsync"/> for moving to other categories.
         /// Use <see cref="RemoveParentAsync"/> to move out of a category.
         /// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
         /// </summary>
         /// <param name="mode">The mode. Valid: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up</param>
         /// <param name="position">The position.</param>
         /// <param name="reason">The reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="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="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 givven 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. Will move out of parent if null.</param>
         /// <param name="lock_permissions">Sync permissions with parent. Defaults to null.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <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>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
         public Task ModifyParentAsync(DiscordChannel? newParent = null, bool? lock_permissions = null, string reason = null)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
         {
             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._channels.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 chns = this.Guild._channels.Values.Where(xc => xc.Type == this.Type)
                             .OrderBy(xc => xc.Position).ToArray();
 
             var pmds = new RestGuildChannelNewParentPayload[chns.Length];
 
             for (var i = 0; i < chns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelNewParentPayload
                 {
                     ChannelId = chns[i].Id,
                     Position = chns[i].Position >= position ? chns[i].Position + 1 : chns[i].Position,
                 };
                 if (chns[i].Id == this.Id)
                 {
                     pmds[i].Position = position;
                     pmds[i].ParentId = newParent is not null ? newParent.Id : null;
                     pmds[i].LockPermissions = lock_permissions;
                 }
             }
 
             return this.Discord.ApiClient.ModifyGuildChannelParentAsync(this.Guild.Id, pmds, reason);
         }
 
         /// <summary>
         /// Moves the channel out of a category.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveParentAsync(string reason = null)
         {
             if (this.Guild == null)
                 throw new ArgumentException("Cannot modify parent of non-guild channels.");
             if (!this.IsMovableInParent())
                 throw new NotSupportedException("You can't move this type of channel in categories.");
 
             var position = this.Guild._channels.Values.Where(xc => xc.Type == this.Type && xc.Parent is null) //gets list of same type channels with no parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
             var chns = this.Guild._channels.Values.Where(xc => xc.Type == this.Type)
                 .OrderBy(xc => xc.Position).ToArray();
 
             var pmds = new RestGuildChannelNoParentPayload[chns.Length];
 
             for (var i = 0; i < chns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelNoParentPayload
                 {
                     ChannelId = chns[i].Id,
                 };
                 if (chns[i].Id == this.Id)
                 {
                     pmds[i].Position = 1;
                     pmds[i].ParentId = null;
                 }
                 else
                 {
                     pmds[i].Position = chns[i].Position < this.Position ? chns[i].Position + 1 : chns[i].Position;
                 }
             }
 
             return this.Discord.ApiClient.DetachGuildChannelParentAsync(this.Guild.Id, pmds, reason);
         }
 
         /// <summary>
         /// Returns a list of messages before a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="before">Message to fetch before from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
             => this.GetMessagesInternalAsync(limit, before, null, null);
 
         /// <summary>
         /// Returns a list of messages after a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="after">Message to fetch after from.</param>
         /// </summary>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, after, null);
 
         /// <summary>
         /// Returns a list of messages around a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="around">Message to fetch around from.</param>
         /// </summary>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, null, around);
 
         /// <summary>
         /// Returns a list of messages from the last message in the channel.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// </summary>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
             this.GetMessagesInternalAsync(limit, null, null, null);
 
         /// <summary>
         /// Returns a list of messages
         /// </summary>
         /// <param name="limit">How many messages should be returned.</param>
         /// <param name="before">Get messages before snowflake.</param>
         /// <param name="after">Get messages after snowflake.</param>
         /// <param name="around">Get messages around snowflake.</param>
         private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
         {
             if (!this.IsWriteable())
                 throw new ArgumentException("Cannot get the messages of a non-text channel.");
 
             if (limit < 0)
                 throw new ArgumentException("Cannot get a negative number of messages.");
 
             if (limit == 0)
                 return Array.Empty<DiscordMessage>();
 
             //return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
             if (limit > 100 && around != null)
                 throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
             var msgs = new List<DiscordMessage>(limit);
             var remaining = limit;
             ulong? last = null;
             var isAfter = after != null;
 
             int lastCount;
             do
             {
                 var fetchSize = remaining > 100 ? 100 : remaining;
                 var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
                 lastCount = fetch.Count;
                 remaining -= lastCount;
 
                 if (!isAfter)
                 {
                     msgs.AddRange(fetch);
                     last = fetch.LastOrDefault()?.Id;
                 }
                 else
                 {
                     msgs.InsertRange(0, fetch);
                     last = fetch.FirstOrDefault()?.Id;
                 }
             }
             while (remaining > 0 && lastCount > 0);
 
             return new ReadOnlyCollection<DiscordMessage>(msgs);
         }
 
         /// <summary>
-        /// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="BadRequestException"/> error.
+        /// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
         /// </summary>
         /// <param name="messages">A collection of messages to delete.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
         {
             // don't enumerate more than once
             var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
             if (messages == null || !msgs.Any())
                 throw new ArgumentException("You need to specify at least one message to delete.");
 
             if (msgs.Count() < 2)
             {
                 await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
                 return;
             }
 
             for (var i = 0; i < msgs.Count(); i += 100)
                 await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a message
         /// </summary>
         /// <param name="message">The message to be deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteMessageAsync(DiscordMessage message, string reason = null)
             => this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
         /// <summary>
         /// Returns a list of invite objects
         /// </summary>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
         {
             return 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="max_age">Duration of invite in seconds before expiry, or 0 for never.  Defaults to 86400.</param>
         /// <param name="max_uses">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="target_type">The target type. Defaults to null.</param>
         /// <param name="target_application">The target activity. Defaults to null.</param>
         /// <param name="target_user">The target user id. Defaults to null.</param>
         /// <param name="reason">The audit log reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordInvite> CreateInviteAsync(int max_age = 86400, int max_uses = 0, bool temporary = false, bool unique = false, TargetType? target_type = null, TargetActivity? target_application = null, ulong? target_user = null, string reason = null)
             => this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, max_age, max_uses, target_type, target_application, target_user, temporary, unique, reason);
 
         #region Stage
 
         /// <summary>
         /// Opens a stage.
         /// </summary>
         /// <param name="topic">Topic of the stage.</param>
         /// <param name="send_start_notification">Whether @everyone should be notified.</param>
         /// <param name="privacy_level">Privacy level of the stage (Defaults to <see cref="StagePrivacyLevel.GuildOnly"/>.</param>
         /// <param name="reason">Audit log reason.</param>
         /// <returns>Stage instance</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordStageInstance> OpenStageAsync(string topic, bool send_start_notification = false, StagePrivacyLevel privacy_level = StagePrivacyLevel.GuildOnly, string reason = null)
             => await this.Discord.ApiClient.CreateStageInstanceAsync(this.Id, topic, send_start_notification, privacy_level, reason);
 
         /// <summary>
         /// Modifies a stage topic.
         /// </summary>
         /// <param name="topic">New topic of the stage.</param>
         /// <param name="privacy_level">New privacy level of the stage.</param>
         /// <param name="reason">Audit log reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task ModifyStageAsync(Optional<string> topic, Optional<StagePrivacyLevel> privacy_level, string reason = null)
             => await this.Discord.ApiClient.ModifyStageInstanceAsync(this.Id, topic, privacy_level, reason);
 
         /// <summary>
         /// Closes a stage.
         /// </summary>
         /// <param name="reason">Audit log reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task CloseStageAsync(string reason = null)
             => await this.Discord.ApiClient.DeleteStageInstanceAsync(this.Id, reason);
 
         /// <summary>
         /// Gets a stage.
         /// </summary>
         /// <returns>The requested stage.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordStageInstance> GetStageAsync()
             => await this.Discord.ApiClient.GetStageInstanceAsync(this.Id);
 
         #endregion
 
         #region 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="auto_archive_duration"><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="rate_limit_per_user">The per user ratelimit, aka slowdown.</param>
         /// <param name="reason">Audit log reason.</param>
         /// <returns>The created thread.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePublicThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> or if creating a private thread the <see cref="Permissions.CreatePrivateThreads"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="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="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 auto_archive_duration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rate_limit_per_user = null, string reason = null)
         {
             return (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, auto_archive_duration)
                     ? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, auto_archive_duration, type, rate_limit_per_user, reason)
                     : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(auto_archive_duration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.")
                 : throw new NotSupportedException($"Cannot create a private thread. Guild needs to be boost tier two.")
                 : Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, auto_archive_duration)
                     ? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, auto_archive_duration, this.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rate_limit_per_user, reason)
                 : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(auto_archive_duration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
         }
 
         /// <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="reason">The reason.</param>
         /// <returns>A scheduled event.</returns>
-        /// <exception cref="NotFoundException">Thrown when the ressource 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the ressource does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, string description = null, 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, reason);
         }
 
 
         /// <summary>
         /// Gets joined archived private threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <param name="before">Get threads created before this thread id.</param>
         /// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong? before, int? limit)
             => await this.Discord.ApiClient.GetJoinedPrivateArchivedThreadsAsync(this.Id, before, limit);
 
         /// <summary>
         /// Gets archived public threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <param name="before">Get threads created before this thread id.</param>
         /// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong? before, int? limit)
             => await this.Discord.ApiClient.GetPublicArchivedThreadsAsync(this.Id, before, limit);
 
         /// <summary>
         /// Gets archived private threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <param name="before">Get threads created before this thread id.</param>
         /// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong? before, int? limit)
             => await this.Discord.ApiClient.GetPrivateArchivedThreadsAsync(this.Id, before, limit);
 
         #endregion
 
         /// <summary>
         /// Adds a channel permission overwrite for specified role.
         /// </summary>
         /// <param name="role">The role to have the permission added.</param>
         /// <param name="allow">The permissions to allow.</param>
         /// <param name="deny">The permissions to deny.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddOverwriteAsync(DiscordRole role, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
             => this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, role.Id, allow, deny, "role", reason);
 
 
         /// <summary>
         /// Adds a channel permission overwrite for specified member.
         /// </summary>
         /// <param name="member">The member to have the permission added.</param>
         /// <param name="allow">The permissions to allow.</param>
         /// <param name="deny">The permissions to deny.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddOverwriteAsync(DiscordMember member, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
             => this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, member.Id, allow, deny, "member", reason);
 
         /// <summary>
         /// Deletes a channel permission overwrite for specified member.
         /// </summary>
         /// <param name="member">The member to have the permission deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteOverwriteAsync(DiscordMember member, string reason = null)
             => this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, member.Id, reason);
 
         /// <summary>
         /// Deletes a channel permission overwrite for specified role.
         /// </summary>
         /// <param name="role">The role to have the permission deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteOverwriteAsync(DiscordRole role, string reason = null)
             => this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, role.Id, reason);
 
         /// <summary>
         /// Post a typing indicator
         /// </summary>
 
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task TriggerTypingAsync()
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot start typing in a non-text channel.")
                 : this.Discord.ApiClient.TriggerTypingAsync(this.Id);
         }
 
         /// <summary>
         /// Returns all pinned messages
         /// </summary>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync()
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("A non-text channel does not have pinned messages.")
                 : this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
         }
 
         /// <summary>
         /// Create a new webhook
         /// </summary>
         /// <param name="name">The name of the webhook.</param>
         /// <param name="avatar">The image for the default webhook avatar.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordWebhook> CreateWebhookAsync(string name, Optional<Stream> avatar = default, string reason = null)
         {
             var av64 = Optional.FromNoValue<string>();
             if (avatar.HasValue && avatar.Value != null)
                 using (var imgtool = new ImageTool(avatar.Value))
                     av64 = imgtool.GetBase64();
             else if (avatar.HasValue)
                 av64 = null;
 
             return await this.Discord.ApiClient.CreateWebhookAsync(this.Id, name, av64, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a list of webhooks
         /// </summary>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
             => this.Discord.ApiClient.GetChannelWebhooksAsync(this.Id);
 
         /// <summary>
         /// Moves a member to this voice channel
         /// </summary>
         /// <param name="member">The member to be moved.</param>
 
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exists or if the Member does not exists.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task PlaceMemberAsync(DiscordMember member)
         {
             if (!this.IsVoiceJoinable())
                 throw new ArgumentException("Cannot place a member in a non-voice channel.");
 
             await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, member.Id, default, default, default,
                 default, this.Id, null).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Follows a news channel
         /// </summary>
         /// <param name="targetChannel">Channel to crosspost messages to</param>
         /// <exception cref="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)
         {
             return this.Type != ChannelType.News
                 ? throw new ArgumentException("Cannot follow a non-news channel.")
                 : this.Discord.ApiClient.FollowChannelAsync(this.Id, targetChannel.Id);
         }
 
         /// <summary>
         /// Publishes a message in a news channel to following channels
         /// </summary>
         /// <param name="message">Message to publish</param>
         /// <exception cref="ArgumentException">Thrown when the message has already been crossposted</exception>
         /// <exception cref="UnauthorizedException">
         ///     Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> and/or <see cref="Permissions.SendMessages"/>
         /// </exception>
         public Task<DiscordMessage> CrosspostMessageAsync(DiscordMessage message)
         {
             return (message.Flags & MessageFlags.Crossposted) == MessageFlags.Crossposted
                 ? throw new ArgumentException("Message is already crossposted.")
                 : this.Discord.ApiClient.CrosspostMessageAsync(this.Id, message.Id);
         }
 
         /// <summary>
         /// Updates the current user's suppress state in this channel, if stage channel.
         /// </summary>
         /// <param name="suppress">Toggles the suppress state.</param>
         /// <param name="requestToSpeakTimestamp">Sets the time the user requested to speak.</param>
         /// <exception cref="ArgumentException">Thrown when the channel is not a stage channel.</exception>
         public async Task UpdateCurrentUserVoiceStateAsync(bool? suppress, DateTimeOffset? requestToSpeakTimestamp = null)
         {
             if (this.Type != ChannelType.Stage)
                 throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
             await this.Discord.ApiClient.UpdateCurrentUserVoiceStateAsync(this.GuildId.Value, this.Id, suppress, requestToSpeakTimestamp).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Calculates permissions for a given member.
         /// </summary>
         /// <param name="mbr">Member to calculate permissions for.</param>
         /// <returns>Calculated permissions for a given member.</returns>
         public Permissions PermissionsFor(DiscordMember mbr)
         {
             // future note: might be able to simplify @everyone role checks to just check any role ... but I'm not sure
             // xoxo, ~uwx
             //
             // you should use a single tilde
             // ~emzi
 
             // user > role > everyone
             // allow > deny > undefined
             // =>
             // user allow > user deny > role allow > role deny > everyone allow > everyone deny
             // thanks to meew0
 
             if (this.IsPrivate || this.Guild == null)
                 return Permissions.None;
 
             if (this.Guild.OwnerId == mbr.Id)
                 return PermissionMethods.FULL_PERMS;
 
             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).ToArray();
 
             // assign permissions from member's roles (in order)
             perms |= mbRoles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
             // Adminstrator grants all permissions and cannot be overridden
             if ((perms & Permissions.Administrator) == Permissions.Administrator)
                 return PermissionMethods.FULL_PERMS;
 
             // channel overrides for roles that member is in
             var mbRoleOverrides = mbRoles
                 .Select(xr => this._permissionOverwrites.FirstOrDefault(xo => xo.Id == xr.Id))
                 .Where(xo => xo != null)
                 .ToList();
 
             // assign channel permission overwrites for @everyone pseudo-role
             var everyoneOverwrites = this._permissionOverwrites.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._permissionOverwrites.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()
         {
             return this.Type == ChannelType.Category
                 ? $"Channel Category {this.Name} ({this.Id})"
                 : this.Type == ChannelType.Text || this.Type == ChannelType.News || this.IsThread()
                 ? $"Channel #{this.Name} ({this.Id})"
                 : this.IsVoiceJoinable()
                 ? $"Channel #!{this.Name} ({this.Id})"
                 : !string.IsNullOrWhiteSpace(this.Name) ? $"Channel {this.Name} ({this.Id})" : $"Channel {this.Id}";
         }
         #endregion
 
         /// <summary>
         /// Checks whether this <see cref="DiscordChannel"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordChannel"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordChannel);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordChannel"/> is equal to another <see cref="DiscordChannel"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordChannel"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordChannel"/> is equal to this <see cref="DiscordChannel"/>.</returns>
         public bool Equals(DiscordChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordChannel"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordChannel"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordChannel"/> objects are equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are equal.</returns>
         public static bool operator ==(DiscordChannel e1, DiscordChannel e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordChannel"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are not equal.</returns>
         public static bool operator !=(DiscordChannel e1, DiscordChannel e2)
             => !(e1 == e2);
     }
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.cs b/DisCatSharp/Entities/Guild/DiscordGuild.cs
index 70e8b8282..c8fd68bc7 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,3477 +1,3477 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 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;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a Discord guild.
     /// </summary>
     public 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 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; } = 0;
 
         /// <summary>
         /// Gets the guild's AFK voice channel.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel AfkChannel
             => this.GetChannel(this.AfkChannelId);
 
         /// <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._roles);
 
         [JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordRole> _roles;
 
         /// <summary>
         /// Gets a collection of this guild's stickers.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordSticker> Stickers => new ReadOnlyConcurrentDictionary<ulong, DiscordSticker>(this._stickers);
 
         [JsonProperty("stickers", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordSticker> _stickers;
 
         /// <summary>
         /// Gets a collection of this guild's emojis.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordEmoji> Emojis => new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(this._emojis);
 
         [JsonProperty("emojis", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordEmoji> _emojis;
 
         /// <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; }
 
 #pragma warning disable CS1734
         /// <summary>
         /// Gets the approximate number of members in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having <paramref name = "withCounts"></paramref> 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 <paramref name = "withCounts"></paramref> set to true.
         /// </summary>
         [JsonProperty("approximate_presence_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? ApproximatePresenceCount { get; internal set; }
 
 #pragma warning restore CS1734
         /// <summary>
         /// Gets the maximum amount of users allowed per video channel.
         /// </summary>
         [JsonProperty("max_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
         public int? MaxVideoChannelUsers { get; internal set; }
 
         /// <summary>
         /// Gets a dictionary of all the voice states for this guilds. The key for this dictionary is the ID of the user
         /// the voice state corresponds to.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordVoiceState> VoiceStates => new ReadOnlyConcurrentDictionary<ulong, DiscordVoiceState>(this._voiceStates);
 
         [JsonProperty("voice_states", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordVoiceState> _voiceStates;
 
         /// <summary>
         /// Gets a dictionary of all the members that belong to this guild. The dictionary's key is the member ID.
         /// </summary>
         [JsonIgnore] // TODO overhead of => vs Lazy? it's a struct
         public IReadOnlyDictionary<ulong, DiscordMember> Members => new ReadOnlyConcurrentDictionary<ulong, DiscordMember>(this._members);
 
         [JsonProperty("members", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordMember> _members;
 
         /// <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._channels);
 
         [JsonProperty("channels", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordChannel> _channels;
 
         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> _threads = 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> _stageInstances = 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> _scheduledEvents = new();
 
         /// <summary>
         /// Gets the guild member for current user.
         /// </summary>
         [JsonIgnore]
         public DiscordMember CurrentMember
             => this._current_member_lazy.Value;
 
         [JsonIgnore]
         private readonly Lazy<DiscordMember> _current_member_lazy;
 
         /// <summary>
         /// Gets the @everyone role for this guild.
         /// </summary>
         [JsonIgnore]
         public DiscordRole EveryoneRole
             => this.GetRole(this.Id);
 
         [JsonIgnore]
         internal bool _isOwner;
 
         /// <summary>
         /// Gets whether the current user is the guild's owner.
         /// </summary>
         [JsonProperty("owner", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsOwner
         {
             get => this._isOwner || this.OwnerId == this.Discord.CurrentUser.Id;
             internal set => this._isOwner = 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 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> raw_channels = this._channels.Values.ToList();
 
             Dictionary<ulong, List<DiscordChannel>> ordered_channels = new();
 
             ordered_channels.Add(0, new List<DiscordChannel>());
 
             foreach (var channel in raw_channels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
             {
                 ordered_channels.Add(channel.Id, new List<DiscordChannel>());
             }
 
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
 
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
 
             return ordered_channels;
         }
 
         /// <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 raw_channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
             Dictionary<ulong, List<DiscordChannel>> ordered_channels = new();
 
             ordered_channels.Add(0, new List<DiscordChannel>());
 
             foreach (var channel in raw_channels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
             {
                 ordered_channels.Add(channel.Id, new List<DiscordChannel>());
             }
 
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
 
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
 
             return ordered_channels;
         }
 
         /// <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._current_member_lazy = new Lazy<DiscordMember>(() => (this._members != null && this._members.TryGetValue(this.Discord.CurrentUser.Id, out var member)) ? member : null);
             this._invites = new ConcurrentDictionary<string, DiscordInvite>();
             this.Threads = new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannel>(this._threads);
             this.StageInstances = new ReadOnlyConcurrentDictionary<ulong, DiscordStageInstance>(this._stageInstances);
             this.ScheduledEvents = new ReadOnlyConcurrentDictionary<ulong, DiscordScheduledEvent>(this._scheduledEvents);
         }
 
         #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="access_token">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>
         /// <returns></returns>
         /// <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="access_token"/> 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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="access_token"/> is not found.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddMemberAsync(DiscordUser user, string access_token, string nickname = null, IEnumerable<DiscordRole> roles = null,
             bool muted = false, bool deaf = false)
             => this.Discord.ApiClient.AddGuildMemberAsync(this.Id, user.Id, access_token, nickname, roles, muted, deaf);
 
         /// <summary>
         /// Deletes this guild. Requires the caller to be the owner of the guild.
         /// </summary>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAsync()
             => this.Discord.ApiClient.DeleteGuildAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild.
         /// </summary>
         /// <param name="action">Action to perform on this guild..</param>
         /// <returns>The modified guild object.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> ModifyAsync(Action<GuildEditModel> action)
         {
             var mdl = new GuildEditModel();
             action(mdl);
 
             var afkChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.AfkChannel.HasValue && mdl.AfkChannel.Value.Type != ChannelType.Voice && mdl.AfkChannel.Value != null)
                 throw new ArgumentException("AFK channel needs to be a voice channel.");
             else if (mdl.AfkChannel.HasValue && mdl.AfkChannel.Value != null)
                 afkChannelId = mdl.AfkChannel.Value.Id;
             else if (mdl.AfkChannel.HasValue)
                 afkChannelId = null;
 
             var rulesChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.RulesChannel.HasValue && mdl.RulesChannel.Value != null && mdl.RulesChannel.Value.Type != ChannelType.Text && mdl.RulesChannel.Value.Type != ChannelType.News )
                 throw new ArgumentException("Rules channel needs to be a text channel.");
             else if (mdl.RulesChannel.HasValue && mdl.RulesChannel.Value != null)
                 rulesChannelId = mdl.RulesChannel.Value.Id;
             else if (mdl.RulesChannel.HasValue)
                 rulesChannelId = null;
 
             var publicUpdatesChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.PublicUpdatesChannel.HasValue && mdl.PublicUpdatesChannel.Value != null && mdl.PublicUpdatesChannel.Value.Type != ChannelType.Text && mdl.PublicUpdatesChannel.Value.Type != ChannelType.News)
                 throw new ArgumentException("Public updates channel needs to be a text channel.");
             else if (mdl.PublicUpdatesChannel.HasValue && mdl.PublicUpdatesChannel.Value != null)
                 publicUpdatesChannelId = mdl.PublicUpdatesChannel.Value.Id;
             else if (mdl.PublicUpdatesChannel.HasValue)
                 publicUpdatesChannelId = null;
 
             var systemChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.SystemChannel.HasValue && mdl.SystemChannel.Value != null && mdl.SystemChannel.Value.Type != ChannelType.Text && mdl.SystemChannel.Value.Type != ChannelType.News)
                 throw new ArgumentException("Public updates channel needs to be a text channel.");
             else if (mdl.SystemChannel.HasValue && mdl.SystemChannel.Value != null)
                 systemChannelId = mdl.SystemChannel.Value.Id;
             else if (mdl.SystemChannel.HasValue)
                 systemChannelId = null;
 
             var iconb64 = Optional.FromNoValue<string>();
             if (mdl.Icon.HasValue && mdl.Icon.Value != null)
                 using (var imgtool = new ImageTool(mdl.Icon.Value))
                     iconb64 = imgtool.GetBase64();
             else if (mdl.Icon.HasValue)
                 iconb64 = null;
 
             var splashb64 = Optional.FromNoValue<string>();
             if (mdl.Splash.HasValue && mdl.Splash.Value != null)
                 using (var imgtool = new ImageTool(mdl.Splash.Value))
                     splashb64 = imgtool.GetBase64();
             else if (mdl.Splash.HasValue)
                 splashb64 = null;
 
             var bannerb64 = Optional.FromNoValue<string>();
             if (mdl.Banner.HasValue && mdl.Banner.Value != null)
                 using (var imgtool = new ImageTool(mdl.Banner.Value))
                     bannerb64 = imgtool.GetBase64();
             else if (mdl.Banner.HasValue)
                 bannerb64 = null;
 
             var discoverySplash64 = Optional.FromNoValue<string>();
             if (mdl.DiscoverySplash.HasValue && mdl.DiscoverySplash.Value != null)
                 using (var imgtool = new ImageTool(mdl.DiscoverySplash.Value))
                     discoverySplash64 = imgtool.GetBase64();
             else if (mdl.DiscoverySplash.HasValue)
                 discoverySplash64 = null;
 
             var description = Optional.FromNoValue<string>();
             if (mdl.Description.HasValue && mdl.Description.Value != null)
                 description = mdl.Description;
             else if (mdl.Description.HasValue)
                 description = null;
 
             return await this.Discord.ApiClient.ModifyGuildAsync(this.Id, mdl.Name,
                 mdl.VerificationLevel, mdl.DefaultMessageNotifications, mdl.MfaLevel, mdl.ExplicitContentFilter,
                 afkChannelId, mdl.AfkTimeout, iconb64, mdl.Owner.IfPresent(e => e.Id), splashb64,
                 systemChannelId, mdl.SystemChannelFlags, publicUpdatesChannelId, rulesChannelId,
                 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 auditlog reason.</param>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> ModifyCommunitySettingsAsync(bool enabled, DiscordChannel rulesChannel = null, DiscordChannel publicUpdatesChannel = null, string preferredLocale = "en-US", string description = null, DefaultMessageNotifications defaultMessageNotifications = DefaultMessageNotifications.MentionsOnly, string reason = null)
         {
             var verificationLevel = this.VerificationLevel;
             if(this.VerificationLevel != VerificationLevel.Highest)
             {
                 verificationLevel = VerificationLevel.High;
             }
 
             var explicitContentFilter = ExplicitContentFilter.AllMembers;
 
             var rulesChannelId = Optional.FromNoValue<ulong?>();
             if (rulesChannel != null && rulesChannel.Type != ChannelType.Text && rulesChannel.Type != ChannelType.News)
                 throw new ArgumentException("Rules channel needs to be a text channel.");
             else if (rulesChannel != null)
                 rulesChannelId = rulesChannel.Id;
             else if (rulesChannel == null)
                 rulesChannelId = null;
 
             var publicUpdatesChannelId = Optional.FromNoValue<ulong?>();
             if (publicUpdatesChannel != null && publicUpdatesChannel.Type != ChannelType.Text && publicUpdatesChannel.Type != ChannelType.News)
                 throw new ArgumentException("Public updates channel needs to be a text channel.");
             else if (publicUpdatesChannel != null)
                 publicUpdatesChannelId = publicUpdatesChannel.Id;
             else if (publicUpdatesChannel == null)
                 publicUpdatesChannelId = null;
 
             List<string> features = new();
             var rfeatures = this.RawFeatures.ToList();
             if (this.RawFeatures.Contains("COMMUNITY") && enabled)
             {
                 features = rfeatures;
             } else if(!this.RawFeatures.Contains("COMMUNITY") && enabled)
             {
                 rfeatures.Add("COMMUNITY");
                 features = rfeatures;
             }
             else if (this.RawFeatures.Contains("COMMUNITY") && !enabled)
             {
                 rfeatures.Remove("COMMUNITY");
                 features = rfeatures;
             } else if(!this.RawFeatures.Contains("COMMUNITY") && !enabled)
             {
                 features = rfeatures;
             }
 
             return await this.Discord.ApiClient.ModifyGuildCommunitySettingsAsync(this.Id, features, rulesChannelId, publicUpdatesChannelId, preferredLocale, description, defaultMessageNotifications, explicitContentFilter, verificationLevel, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Bans a specified member from this guild.
         /// </summary>
         /// <param name="member">Member to ban.</param>
         /// <param name="delete_message_days">How many days to remove messages from.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanMemberAsync(DiscordMember member, int delete_message_days = 0, string reason = null)
             => this.Discord.ApiClient.CreateGuildBanAsync(this.Id, member.Id, delete_message_days, reason);
 
         /// <summary>
         /// Bans a specified user by ID. This doesn't require the user to be in this guild.
         /// </summary>
         /// <param name="user_id">ID of the user to ban.</param>
         /// <param name="delete_message_days">How many days to remove messages from.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanMemberAsync(ulong user_id, int delete_message_days = 0, string reason = null)
             => this.Discord.ApiClient.CreateGuildBanAsync(this.Id, user_id, delete_message_days, reason);
 
         /// <summary>
         /// Unbans a user from this guild.
         /// </summary>
         /// <param name="user">User to unban.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanMemberAsync(DiscordUser user, string reason = null)
             => this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user.Id, reason);
 
         /// <summary>
         /// Unbans a user by ID.
         /// </summary>
         /// <param name="user_id">ID of the user to unban.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanMemberAsync(ulong user_id, string reason = null)
             => this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user_id, reason);
 
         /// <summary>
         /// Leaves this guild.
         /// </summary>
         /// <returns></returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task LeaveAsync()
             => this.Discord.ApiClient.LeaveGuildAsync(this.Id);
 
         /// <summary>
         /// Gets the bans for this guild.
         /// </summary>
         /// <returns>Collection of bans in this guild.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordBan>> GetBansAsync()
             => this.Discord.ApiClient.GetGuildBansAsync(this.Id);
 
         /// <summary>
         /// Gets a ban for a specific user.
         /// </summary>
         /// <param name="userId">The Id of the user to get the ban for.</param>
-        /// <exception cref="NotFoundException">Thrown when the specified user is not banned.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
         /// <returns>The requested ban object.</returns>
         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>
-        /// <exception cref="NotFoundException">Thrown when the specified user is not banned.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
         /// <returns>The requested ban object.</returns>
         public Task<DiscordBan> GetBanAsync(DiscordUser user)
             => this.GetBanAsync(user.Id);
 
         #region Sheduled 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="reason">The reason.</param>
         /// <returns>A scheduled event.</returns>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset? scheduledEndTime = null, DiscordChannel channel = null, DiscordScheduledEventEntityMetadata metadata = null, string description = null, ScheduledEventEntityType type = ScheduledEventEntityType.StageInstance, string reason = null)
             => 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, 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="reason">The reason.</param>
         /// <returns>A scheduled event.</returns>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> CreateExternalScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset scheduledEndTime, string location, string description = null, string reason = null)
             => await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, null, new DiscordScheduledEventEntityMetadata(location), name, scheduledStartTime, scheduledEndTime, description, ScheduledEventEntityType.External, 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="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> GetScheduledEventAsync(ulong scheduledEventId, bool? withUserCount = null)
             => this._scheduledEvents.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 sheduled event.</returns>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> GetScheduledEventAsync(DiscordScheduledEvent scheduledEvent, bool? withUserCount = null)
             => await this.GetScheduledEventAsync(scheduledEvent.Id, withUserCount);
 
         /// <summary>
         /// Gets the guilds scheduled events.
         /// </summary>
         /// <param name="withUserCount">Whether to include user count.</param>
         /// <returns>A list of the guilds scheduled events.</returns>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> GetScheduledEventsAsync(bool? withUserCount = null)
             => await this.Discord.ApiClient.ListGuildScheduledEventsAsync(this.Id, withUserCount);
         #endregion
 
         /// <summary>
         /// Creates a new text channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new channel.</param>
         /// <param name="parent">Category to put this channel in.</param>
         /// <param name="topic">Topic of the channel.</param>
         /// <param name="overwrites">Permission overwrites for this channel.</param>
         /// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <param name="perUserRateLimit">Slow mode timeout for users.</param>
         /// <returns>The newly-created channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateTextChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Text, parent, topic, null, null, overwrites, nsfw, perUserRateLimit, null, 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="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateChannelCategoryAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Category, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), 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="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="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="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.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), 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 stage channel.</param>
         /// <param name="overwrites">Permission overwrites for this news channel.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created news channel.</returns>
         /// <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="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="NotSupportedException">Thrown when the guilds has not enabled community.</exception>
         public Task<DiscordChannel> CreateNewsChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.News, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, 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="user_limit">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="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateVoiceChannelAsync(string name, DiscordChannel parent = null, int? bitrate = null, int? user_limit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, VideoQualityMode? qualityMode = null, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Voice, parent, Optional.FromNoValue<string>(), bitrate, user_limit, overwrites, null, Optional.FromNoValue<int?>(), qualityMode, 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="reason">Reason for audit logs.</param>
         /// <returns>The newly-created channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, string reason = null)
         {
             // technically you can create news/store channels but not always
             return 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, 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="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordThreadResult> GetActiveThreadsAsync()
             => this.Discord.ApiClient.GetActiveThreadsAsync(this.Id);
 
         // this is to commemorate the Great DAPI Channel Massacre of 2017-11-19.
         /// <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="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<int> GetPruneCountAsync(int days = 7, IEnumerable<DiscordRole> includedRoles = null)
         {
             if (includedRoles != null)
             {
                 includedRoles = includedRoles.Where(r => r != null);
                 var roleCount = includedRoles.Count();
                 var roleArr = includedRoles.ToArray();
                 var rawRoleIds = new List<ulong>();
 
                 for (var i = 0; i < roleCount; i++)
                 {
                     if (this._roles.ContainsKey(roleArr[i].Id))
                         rawRoleIds.Add(roleArr[i].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="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<int?> PruneAsync(int days = 7, bool computePruneCount = true, IEnumerable<DiscordRole> includedRoles = null, string reason = null)
         {
             if (includedRoles != null)
             {
                 includedRoles = includedRoles.Where(r => r != null);
                 var roleCount = includedRoles.Count();
                 var roleArr = includedRoles.ToArray();
                 var rawRoleIds = new List<ulong>();
 
                 for (var i = 0; i < roleCount; i++)
                 {
                     if (this._roles.ContainsKey(roleArr[i].Id))
                         rawRoleIds.Add(roleArr[i].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="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordIntegration>> GetIntegrationsAsync()
             => this.Discord.ApiClient.GetGuildIntegrationsAsync(this.Id);
 
         /// <summary>
         /// Attaches an integration from current user to this guild.
         /// </summary>
         /// <param name="integration">Integration to attach.</param>
         /// <returns>The integration after being attached to the guild.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordIntegration> AttachUserIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.CreateGuildIntegrationAsync(this.Id, integration.Type, integration.Id);
 
         /// <summary>
         /// Modifies an integration in this guild.
         /// </summary>
         /// <param name="integration">Integration to modify.</param>
         /// <param name="expire_behaviour">Number of days after which the integration expires.</param>
         /// <param name="expire_grace_period">Length of grace period which allows for renewing the integration.</param>
         /// <param name="enable_emoticons">Whether emotes should be synced from this integration.</param>
         /// <returns>The modified integration.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordIntegration> ModifyIntegrationAsync(DiscordIntegration integration, int expire_behaviour, int expire_grace_period, bool enable_emoticons)
             => this.Discord.ApiClient.ModifyGuildIntegrationAsync(this.Id, integration.Id, expire_behaviour, expire_grace_period, enable_emoticons);
 
         /// <summary>
         /// Removes an integration from this guild.
         /// </summary>
         /// <param name="integration">Integration to remove.</param>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.DeleteGuildIntegrationAsync(this.Id, integration);
 
         /// <summary>
         /// Forces re-synchronization of an integration for this guild.
         /// </summary>
         /// <param name="integration">Integration to synchronize.</param>
         /// <returns></returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task SyncIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.SyncGuildIntegrationAsync(this.Id, integration.Id);
 
         /// <summary>
         /// Gets the voice regions for this guild.
         /// </summary>
         /// <returns>Voice regions available for this guild.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
         {
             var vrs = await this.Discord.ApiClient.GetGuildVoiceRegionsAsync(this.Id).ConfigureAwait(false);
             foreach (var xvr in vrs)
                 this.Discord.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 
             return vrs;
         }
 
         /// <summary>
         /// Gets an invite from this guild from an invite code.
         /// </summary>
         /// <param name="code">The invite code</param>
         /// <returns>An invite, or null if not in cache.</returns>
         public DiscordInvite GetInvite(string code)
             => this._invites.TryGetValue(code, out var invite) ? invite : null;
 
         /// <summary>
         /// Gets all the invites created for all the channels in this guild.
         /// </summary>
         /// <returns>A collection of invites.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
         {
             var res = await this.Discord.ApiClient.GetGuildInvitesAsync(this.Id).ConfigureAwait(false);
 
             var intents = this.Discord.Configuration.Intents;
 
             if (!intents.HasIntent(DiscordIntents.GuildInvites))
             {
                 for (var i = 0; i < res.Count; i++)
                     this._invites[res[i].Code] = res[i];
             }
 
             return res;
         }
 
         /// <summary>
         /// Gets the vanity invite for this guild.
         /// </summary>
         /// <returns>A partial vanity invite.</returns>
         /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordInvite> GetVanityInviteAsync()
             => this.Discord.ApiClient.GetGuildVanityUrlAsync(this.Id);
 
         /// <summary>
         /// Gets all the webhooks created for all the channels in this guild.
         /// </summary>
         /// <returns>A collection of webhooks this guild has.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
             => this.Discord.ApiClient.GetGuildWebhooksAsync(this.Id);
 
         /// <summary>
         /// Gets this guild's widget image.
         /// </summary>
         /// <param name="bannerType">The format of the widget.</param>
         /// <returns>The URL of the widget image.</returns>
         public string GetWidgetImage(WidgetType bannerType = WidgetType.Shield)
         {
             var param = bannerType switch
             {
                 WidgetType.Banner1 => "banner1",
                 WidgetType.Banner2 => "banner2",
                 WidgetType.Banner3 => "banner3",
                 WidgetType.Banner4 => "banner4",
                 _ => "shield",
             };
             return $"{Endpoints.BASE_URI}{Endpoints.GUILDS}/{this.Id}{Endpoints.WIDGET_PNG}?style={param}";
         }
 
         /// <summary>
         /// Gets a member of this guild by their user ID.
         /// </summary>
         /// <param name="userId">ID of the member to get.</param>
         /// <returns>The requested member.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMember> GetMemberAsync(ulong userId)
         {
             if (this._members != null && this._members.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._members != null)
                 {
                     this._members[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="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyCollection<DiscordMember>> GetAllMembersAsync()
         {
             var recmbr = new HashSet<DiscordMember>();
 
             var recd = 1000;
             var last = 0ul;
             while (recd > 0)
             {
                 var tms = await this.Discord.ApiClient.ListGuildMembersAsync(this.Id, 1000, last == 0 ? null : (ulong?)last).ConfigureAwait(false);
                 recd = tms.Count;
 
                 foreach (var xtm in tms)
                 {
                     var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
                     usr = this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
                     {
                         old.Username = usr.Username;
                         old.Discord = usr.Discord;
                         old.AvatarHash = usr.AvatarHash;
 
                         return old;
                     });
 
                     recmbr.Add(new DiscordMember(xtm) { Discord = this.Discord, _guild_id = 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="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="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordChannel>> GetChannelsAsync()
             => this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
         /// <summary>
         /// Creates a new role in this guild.
         /// </summary>
         /// <param name="name">Name of the role.</param>
         /// <param name="permissions">Permissions for the role.</param>
         /// <param name="color">Color for the role.</param>
         /// <param name="hoist">Whether the role is to be hoisted.</param>
         /// <param name="mentionable">Whether the role is to be mentionable.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created role.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordRole> CreateRoleAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
             => this.Discord.ApiClient.CreateGuildRoleAsync(this.Id, name, permissions, color?.Value, hoist, mentionable, reason);
 
         /// <summary>
         /// Gets a role from this guild by its ID.
         /// </summary>
         /// <param name="id">ID of the role to get.</param>
         /// <returns>Requested role.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordRole GetRole(ulong id)
             => this._roles.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="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordChannel GetChannel(ulong id)
             => (this._channels != null && this._channels.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="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordThreadChannel GetThread(ulong id)
             => (this._threads != null && this._threads.TryGetValue(id, out var thread)) ? thread : null;
 
         /// <summary>
         /// Gets audit log entries for this guild.
         /// </summary>
         /// <param name="limit">Maximum number of entries to fetch.</param>
         /// <param name="by_member">Filter by member responsible.</param>
         /// <param name="action_type">Filter by action type.</param>
         /// <returns>A collection of requested audit log entries.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember by_member = null, AuditLogActionType? action_type = 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, by_member?.Id, (int?)action_type).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 ahr = alrs.SelectMany(xa => xa.Webhooks)
                 .GroupBy(xh => xh.Id)
                 .Select(xgh => xgh.First());
 
             var ams = amr.Select(xau => (this._members != null && this._members.TryGetValue(xau.Id, out var member)) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, _guild_id = this.Id });
             var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
             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.GuildUpdate:
                         entry = new DiscordAuditLogGuildEntry
                         {
                             Target = this
                         };
 
                         var entrygld = entry as DiscordAuditLogGuildEntry;
                         foreach (var xc in xac.Changes)
                         {
                             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._members != null && this._members.TryGetValue(xc.OldValueUlong, out var oldMember)) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
                                         After = (this._members != null && this._members.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":
                                     ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrygld.AfkChannelChange = 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 }
                                     };
                                     break;
 
                                 case "widget_channel_id":
                                     ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrygld.EmbedChannelChange = 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 }
                                     };
                                     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":
                                     ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrygld.SystemChannelChange = 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 }
                                     };
                                     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 "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.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     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 "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 "bitrate":
                                     entrychn.BitrateChange = 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;
 
                                 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<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     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, _guild_id = 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, _guild_id = 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, _guild_id = 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 "$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;
 
                                 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, _guild_id = this.Id },
                                         After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, _guild_id = 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;
 
                                 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 "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._emojis.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._stageInstances.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._stickers.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 "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._threads.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.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     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 "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._scheduledEvents.TryGetValue(xac.TargetId.Value, out var scheduled_event) ? scheduled_event : 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 "description":
                                     entryse.DescriptionChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     break;
 
                                 case "location":
                                     entryse.LocationChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     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;
 
                     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);
         }
 
         /// <summary>
         /// Gets all of this guild's custom emojis.
         /// </summary>
         /// <returns>All of this guild's custom emojis.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordGuildEmoji>> GetEmojisAsync()
             => this.Discord.ApiClient.GetGuildEmojisAsync(this.Id);
 
         /// <summary>
         /// Gets this guild's specified custom emoji.
         /// </summary>
         /// <param name="id">ID of the emoji to get.</param>
         /// <returns>The requested custom emoji.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> GetEmojiAsync(ulong id)
             => this.Discord.ApiClient.GetGuildEmojiAsync(this.Id, id);
 
         /// <summary>
         /// Creates a new custom emoji for this guild.
         /// </summary>
         /// <param name="name">Name of the new emoji.</param>
         /// <param name="image">Image to use as the emoji.</param>
         /// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns>The newly-created emoji.</returns>
         /// <exception cref="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="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> CreateEmojiAsync(string name, Stream image, IEnumerable<DiscordRole> roles = null, string reason = null)
         {
             if (string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
 
             name = name.Trim();
             if (name.Length < 2 || name.Length > 50)
                 throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.");
 
             if (image == null)
                 throw new ArgumentNullException(nameof(image));
 
             string image64 = null;
             using (var imgtool = new ImageTool(image))
                 image64 = imgtool.GetBase64();
 
             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="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="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> ModifyEmojiAsync(DiscordGuildEmoji emoji, string name, IEnumerable<DiscordRole> roles = null, string reason = null)
         {
             if (emoji == null)
                 throw new ArgumentNullException(nameof(emoji));
 
             if (emoji.Guild.Id != this.Id)
                 throw new ArgumentException("This emoji does not belong to this guild.");
 
             if (string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
 
             name = name.Trim();
             return name.Length < 2 || name.Length > 50
                 ? throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.")
                 : this.Discord.ApiClient.ModifyGuildEmojiAsync(this.Id, emoji.Id, name, roles?.Select(xr => xr.Id), reason);
         }
 
         /// <summary>
         /// Deletes this guild's custom emoji.
         /// </summary>
         /// <param name="emoji">Emoji to delete.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns></returns>
         /// <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="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteEmojiAsync(DiscordGuildEmoji emoji, string reason = null)
         {
             return 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="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordSticker>> GetStickersAsync()
         {
             var stickers = await this.Discord.ApiClient.GetGuildStickersAsync(this.Id);
 
             foreach (var xstr in stickers)
             {
                 this._stickers.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="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="DisCatSharp.Exceptions.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 sticker_id)
             => this.Discord.ApiClient.GetGuildStickerAsync(this.Id, sticker_id);
 
         /// <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="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="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordSticker> CreateStickerAsync(string name, string description, DiscordEmoji emoji, Stream file, StickerFormat format, string reason = null)
         {
             var fileExt = format switch
             {
                 StickerFormat.PNG => "png",
                 StickerFormat.APNG => "png",
                 StickerFormat.LOTTIE => "json",
                 _ => throw new InvalidOperationException("This format is not supported.")
             };
 
             var contentType = format switch
             {
                 StickerFormat.PNG => "image/png",
                 StickerFormat.APNG => "image/png",
                 StickerFormat.LOTTIE => "application/json",
                 _ => throw new InvalidOperationException("This format is not supported.")
             };
 
             return emoji.Id is not 0
                 ? throw new InvalidOperationException("Only unicode emoji can be used for stickers.")
                 : name.Length < 2 || name.Length > 30
                 ? throw new ArgumentOutOfRangeException(nameof(name), "Sticker name needs to be between 2 and 30 characters long.")
                 : description.Length < 1 || description.Length > 100
                 ? throw new ArgumentOutOfRangeException(nameof(description), "Sticker description needs to be between 1 and 100 characters long.")
                 : this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new("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="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="DisCatSharp.Exceptions.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)
         {
 
             string uemoji = null;
 
             if (!this._stickers.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.");
             else 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._stickers.TryGetValue(usticker.Id, out var old))
                 this._stickers.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="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="DisCatSharp.Exceptions.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="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="DisCatSharp.Exceptions.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)
         {
             return !this._stickers.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="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="DisCatSharp.Exceptions.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="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordChannel GetDefaultChannel()
         {
             return this._channels?.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="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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordGuildTemplate>> GetTemplatesAsync()
             => this.Discord.ApiClient.GetGuildTemplatesAsync(this.Id);
 
         /// <summary>
         /// Creates a guild template.
         /// </summary>
         /// <param name="name">Name of the template.</param>
         /// <param name="description">Description of the template.</param>
         /// <returns>The template created.</returns>
-        /// <exception cref="BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
+        /// <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="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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> CreateTemplateAsync(string name, string description = null)
             => this.Discord.ApiClient.CreateGuildTemplateAsync(this.Id, name, description);
 
         /// <summary>
         /// Syncs the template to the current guild's state.
         /// </summary>
         /// <param name="code">The code of the template to sync.</param>
         /// <returns>The template synced.</returns>
-        /// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
+        /// <exception cref="DisCatSharp.Exceptions.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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> SyncTemplateAsync(string code)
             => this.Discord.ApiClient.SyncGuildTemplateAsync(this.Id, code);
 
         /// <summary>
         /// Modifies the template's metadata.
         /// </summary>
         /// <param name="code">The template's code.</param>
         /// <param name="name">Name of the template.</param>
         /// <param name="description">Description of the template.</param>
         /// <returns>The template modified.</returns>
-        /// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
+        /// <exception cref="DisCatSharp.Exceptions.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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> ModifyTemplateAsync(string code, string name = null, string description = null)
             => this.Discord.ApiClient.ModifyGuildTemplateAsync(this.Id, code, name, description);
 
         /// <summary>
         /// Deletes the template.
         /// </summary>
         /// <param name="code">The code of the template to delete.</param>
         /// <returns>The deleted template.</returns>
-        /// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
+        /// <exception cref="DisCatSharp.Exceptions.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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> DeleteTemplateAsync(string code)
             => this.Discord.ApiClient.DeleteGuildTemplateAsync(this.Id, code);
 
         /// <summary>
         /// Gets this guild's membership screening form.
         /// </summary>
         /// <returns>This guild's membership screening form.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildMembershipScreening> GetMembershipScreeningFormAsync()
             => this.Discord.ApiClient.GetGuildMembershipScreeningFormAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild's membership screening form.
         /// </summary>
         /// <param name="action">Action to perform</param>
         /// <returns>The modified screening form.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuildMembershipScreening> ModifyMembershipScreeningFormAsync(Action<MembershipScreeningEditModel> action)
         {
             var mdl = new MembershipScreeningEditModel();
             action(mdl);
             return await this.Discord.ApiClient.ModifyGuildMembershipScreeningFormAsync(this.Id, mdl.Enabled, mdl.Fields, mdl.Description);
         }
 
         /// <summary>
         /// Gets all the application commands in this guild.
         /// </summary>
         /// <returns>A list of application commands in this guild.</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> GetApplicationCommandsAsync() =>
             this.Discord.ApiClient.GetGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id);
 
         /// <summary>
         /// Overwrites the existing application commands in this guild. New commands are automatically created and missing commands are automatically delete
         /// </summary>
         /// <param name="commands">The list of commands to overwrite with.</param>
         /// <returns>The list of guild commands</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
             this.Discord.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id, commands);
 
         /// <summary>
         /// Creates or overwrites a application command in this guild.
         /// </summary>
         /// <param name="command">The command to create.</param>
         /// <returns>The created command.</returns>
         public Task<DiscordApplicationCommand> CreateApplicationCommandAsync(DiscordApplicationCommand command) =>
             this.Discord.ApiClient.CreateGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, command);
 
         /// <summary>
         /// Edits a application command in this guild.
         /// </summary>
         /// <param name="commandId">The id of the command to edit.</param>
         /// <param name="action">Action to perform.</param>
         /// <returns>The edit command.</returns>
         public async Task<DiscordApplicationCommand> EditApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
         {
             var mdl = new ApplicationCommandEditModel();
             action(mdl);
             return await this.Discord.ApiClient.EditGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets this guild's welcome screen.
         /// </summary>
         /// <returns>This guild's welcome screen object.</returns>
-        /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildWelcomeScreen> GetWelcomeScreenAsync() =>
             this.Discord.ApiClient.GetGuildWelcomeScreenAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild's welcome screen.
         /// </summary>
         /// <param name="action">Action to perform.</param>
         /// <returns>The modified welcome screen.</returns>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuildWelcomeScreen> ModifyWelcomeScreenAsync(Action<WelcomeScreenEditModel> action)
         {
             var mdl = new WelcomeScreenEditModel();
             action(mdl);
             return await this.Discord.ApiClient.ModifyGuildWelcomeScreenAsync(this.Id, mdl.Enabled, mdl.WelcomeChannels, mdl.Description).ConfigureAwait(false);
         }
         #endregion
 
         /// <summary>
         /// Returns a string representation of this guild.
         /// </summary>
         /// <returns>String representation of this guild.</returns>
         public override string ToString() => $"Guild {this.Id}; {this.Name}";
 
         /// <summary>
         /// Checks whether this <see cref="DiscordGuild"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordGuild"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordGuild);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordGuild"/> is equal to another <see cref="DiscordGuild"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordGuild"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordGuild"/> is equal to this <see cref="DiscordGuild"/>.</returns>
         public bool Equals(DiscordGuild e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordGuild"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordGuild"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordGuild"/> objects are equal.
         /// </summary>
         /// <param name="e1">First guild to compare.</param>
         /// <param name="e2">Second guild to compare.</param>
         /// <returns>Whether the two guilds are equal.</returns>
         public static bool operator ==(DiscordGuild e1, DiscordGuild e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordGuild"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First guild to compare.</param>
         /// <param name="e2">Second guild to compare.</param>
         /// <returns>Whether the two guilds are not equal.</returns>
         public static bool operator !=(DiscordGuild e1, DiscordGuild e2)
             => !(e1 == e2);
 
     }
 
     /// <summary>
     /// Represents guild verification level.
     /// </summary>
     public enum VerificationLevel : int
     {
         /// <summary>
         /// No verification. Anyone can join and chat right away.
         /// </summary>
         None = 0,
 
         /// <summary>
         /// Low verification level. Users are required to have a verified email attached to their account in order to be able to chat.
         /// </summary>
         Low = 1,
 
         /// <summary>
         /// Medium verification level. Users are required to have a verified email attached to their account, and account age need to be at least 5 minutes in order to be able to chat.
         /// </summary>
         Medium = 2,
 
         /// <summary>
         /// High verification level. Users are required to have a verified email attached to their account, account age need to be at least 5 minutes, and they need to be in the server for at least 10 minutes in order to be able to chat.
         /// </summary>
         High = 3,
 
         /// <summary>
         /// Highest verification level. Users are required to have a verified phone number attached to their account.
         /// </summary>
         Highest = 4
     }
 
     /// <summary>
     /// Represents default notification level for a guild.
     /// </summary>
     public enum DefaultMessageNotifications : int
     {
         /// <summary>
         /// All messages will trigger push notifications.
         /// </summary>
         AllMessages = 0,
 
         /// <summary>
         /// Only messages that mention the user (or a role he's in) will trigger push notifications.
         /// </summary>
         MentionsOnly = 1
     }
 
     /// <summary>
     /// Represents multi-factor authentication level required by a guild to use administrator functionality.
     /// </summary>
     public enum MfaLevel : int
     {
         /// <summary>
         /// Multi-factor authentication is not required to use administrator functionality.
         /// </summary>
         Disabled = 0,
 
         /// <summary>
         /// Multi-factor authentication is required to use administrator functionality.
         /// </summary>
         Enabled = 1
     }
 
     /// <summary>
     /// Represents the value of explicit content filter in a guild.
     /// </summary>
     public enum ExplicitContentFilter : int
     {
         /// <summary>
         /// Explicit content filter is disabled.
         /// </summary>
         Disabled = 0,
 
         /// <summary>
         /// Only messages from members without any roles are scanned.
         /// </summary>
         MembersWithoutRoles = 1,
 
         /// <summary>
         /// Messages from all members are scanned.
         /// </summary>
         AllMembers = 2
     }
 
     /// <summary>
     /// Represents the formats for a guild widget.
     /// </summary>
     public enum WidgetType : int
     {
         /// <summary>
         /// The widget is represented in shield format.
         /// <para>This is the default widget type.</para>
         /// </summary>
         Shield = 0,
 
         /// <summary>
         /// The widget is represented as the first banner type.
         /// </summary>
         Banner1 = 1,
 
         /// <summary>
         /// The widget is represented as the second banner type.
         /// </summary>
         Banner2 = 2,
 
         /// <summary>
         /// The widget is represented as the third banner type.
         /// </summary>
         Banner3 = 3,
 
         /// <summary>
         /// The widget is represented in the fourth banner type.
         /// </summary>
         Banner4 = 4
     }
 
     /// <summary>
     /// Represents the guild features.
     /// </summary>
     public class GuildFeatures
     {
         /// <summary>
         /// Guild has access to set an animated guild icon.
         /// </summary>
         public bool CanSetAnimatedIcon { get; }
 
         /// <summary>
         /// Guild has access to set a guild banner image.
         /// </summary>
         public bool CanSetBanner { get; }
 
         /// <summary>
         /// Guild has access to use commerce features (i.e. create store channels)
         /// </summary>
         public bool CanCreateStoreChannels { get; }
 
         /// <summary>
         /// Guild can enable Welcome Screen, Membership Screening, Stage Channels, News Channels and receives community updates.
         /// Furthermore the guild can apply as a partner and for the discovery (if the prerequisites are given).
         /// <see cref="ChannelType.Stage"/> and <see cref="ChannelType.News"/> is usable.
         /// </summary>
         public bool HasCommunityEnabled { get; }
 
         /// <summary>
         /// Guild is able to be discovered in the discovery.
         /// </summary>
         public bool IsDiscoverable { get; }
 
         /// <summary>
         /// Guild is able to be featured in the discovery.
         /// </summary>
         public bool IsFeatureable { get; }
 
         /// <summary>
         /// Guild has access to set an invite splash background.
         /// </summary>
         public bool CanSetInviteSplash { get; }
 
         /// <summary>
         /// Guild has enabled Membership Screening.
         /// </summary>
         public bool HasMembershipScreeningEnabled { get; }
 
         /// <summary>
         /// Guild has access to create news channels.
         /// <see cref="ChannelType.News"/> is usable.
         /// </summary>
         public bool CanCreateNewsChannels { get; }
 
         /// <summary>
         /// Guild is partnered.
         /// </summary>
         public bool IsPartnered { get; }
 
         /// <summary>
         /// Guild has increased custom emoji slots.
         /// </summary>
         public bool CanUploadMoreEmojis { get; }
 
         /// <summary>
         /// Guild can be previewed before joining via Membership Screening or the discovery.
         /// </summary>
         public bool HasPreviewEnabled { get; }
 
         /// <summary>
         /// Guild has access to set a vanity URL.
         /// </summary>
         public bool CanSetVanityUrl { get; }
 
         /// <summary>
         /// Guild is verified.
         /// </summary>
         public bool IsVerified { get; }
 
         /// <summary>
         /// Guild has access to set 384kbps bitrate in voice (previously VIP voice servers).
         /// </summary>
         public bool CanAccessVipRegions { get; }
 
         /// <summary>
         /// Guild has enabled the welcome screen.
         /// </summary>
         public bool HasWelcomeScreenEnabled { get; }
 
         /// <summary>
         /// Guild has enabled ticketed events.
         /// </summary>
         public bool HasTicketedEventsEnabled { get; }
 
         /// <summary>
         /// Guild has enabled monetization.
         /// </summary>
         public bool HasMonetizationEnabled { get; }
 
         /// <summary>
         /// Guild has increased custom sticker slots.
         /// </summary>
         public bool CanUploadMoreStickers { get; }
 
         /// <summary>
         /// Guild has access to the three day archive time for threads.
         /// Needs Premium Tier 1 (<see cref="PremiumTier.TierOne"/>).
         /// </summary>
         public bool CanSetThreadArchiveDurationThreeDays { get; }
 
         /// <summary>
         /// Guild has access to the seven day archive time for threads.
         /// Needs Premium Tier 2 (<see cref="PremiumTier.TierTwo"/>).
         /// </summary>
         public bool CanSetThreadArchiveDurationSevenDays { get; }
 
         /// <summary>
         /// Guild has access to create private threads.
         /// Needs Premium Tier 2 (<see cref="PremiumTier.TierTwo"/>).
         /// </summary>
         public bool CanCreatePrivateThreads { get; }
 
         /// <summary>
         /// Guild is a hub.
         /// <see cref="ChannelType.GuildDirectory"/> is usable.
         /// </summary>
         public bool IsHub { get; }
 
         /// <summary>
         /// Guild is in a hub.
         /// https://github.com/discord/discord-api-docs/pull/3757/commits/4932d92c9d0c783861bc715bf7ebbabb15114e34
         /// </summary>
         public bool HasDirectoryEntry { get; }
 
         /// <summary>
         /// Guild is linked to a hub.
         /// </summary>
         public bool IsLinkedToHub { get; }
 
         /// <summary>
         /// Guild has full access to threads.
         /// Old Feature.
         /// </summary>
         public bool HasThreadTestingEnabled { get; }
 
         /// <summary>
         /// Guild has access to threads.
         /// </summary>
         public bool HasThreadsEnabled { get; }
 
         /// <summary>
         /// Guild can set role icons.
         /// </summary>
         public bool CanSetRoleIcons { get; }
 
         /// <summary>
         /// Guild has the new thread permissions.
         /// Old Feature.
         /// </summary>
         public bool HasNewThreadPermissions { get; }
 
         /// <summary>
         /// Guild can set thread default auto archive duration.
         /// Old Feature.
         /// </summary>
         public bool CanSetThreadDefaultAutoArchiveDuration { get; }
 
         /// <summary>
         /// Guild has enabled role subsriptions.
         /// </summary>
         public bool HasRoleSubscriptionsEnabled { get; }
 
         /// <summary>
         /// Guild role subsriptions as purchaseable.
         /// </summary>
         public bool RoleSubscriptionsIsAvaiableForPurchase { get; }
 
         /// <summary>
         /// Guild has premium tier 3 override.
         /// </summary>
         public bool PremiumTierThreeOverride { get; }
 
         /// <summary>
         /// Guild has access to text in voice.
         /// Restricted to <see cref="IsStaffOnly"/>.
         /// </summary>
         public bool TextInVoiceEnabled { get; }
 
         /// <summary>
         /// Guild can set an animated banner.
         /// Needs Premium Tier 3 (<see cref="PremiumTier.TierThree"/>).
         /// </summary>
         public bool CanSetAnimatedBanner { get; }
 
         /// <summary>
         /// Guild can set an animated banner.
         /// Needs Premium Tier 3 (<see cref="PremiumTier.TierThree"/>).
         /// </summary>
         public bool CanSetChannelBanner { get; }
 
         /// <summary>
         /// Allows members to customize their avatar, banner and bio for that server.
         /// </summary>
         public bool HasMemberProfiles { get; }
 
         /// <summary>
         /// Guild is restricted to users with the <see cref="UserFlags.Staff"/> badge.
         /// </summary>
         public bool IsStaffOnly { get; }
 
         /// <summary>
         /// String of guild features.
         /// </summary>
         public string FeatureString { get; }
 
         /// <summary>
         /// Checks the guild features and constructs a new <see cref="GuildFeatures"/> object.
         /// </summary>
         /// <param name="guild">Guild to check</param>
         public GuildFeatures(DiscordGuild guild)
         {
             this.CanSetAnimatedIcon = guild.RawFeatures.Contains("ANIMATED_ICON");
             this.CanSetAnimatedBanner = guild.RawFeatures.Contains("ANIMATED_BANNER");
             this.CanSetBanner = guild.RawFeatures.Contains("BANNER");
             this.CanSetChannelBanner = guild.RawFeatures.Contains("CHANNEL_BANNER");
             this.CanCreateStoreChannels = guild.RawFeatures.Contains("COMMERCE");
             this.HasCommunityEnabled = guild.RawFeatures.Contains("COMMUNITY");
             this.IsDiscoverable = !guild.RawFeatures.Contains("DISCOVERABLE_DISABLED") && guild.RawFeatures.Contains("DISCOVERABLE");
             this.IsFeatureable = guild.RawFeatures.Contains("FEATURABLE");
             this.CanSetInviteSplash = guild.RawFeatures.Contains("INVITE_SPLASH");
             this.HasMembershipScreeningEnabled = guild.RawFeatures.Contains("MEMBER_VERIFICATION_GATE_ENABLED");
             this.CanCreateNewsChannels = guild.RawFeatures.Contains("NEWS");
             this.IsPartnered = guild.RawFeatures.Contains("PARTNERED");
             this.CanUploadMoreEmojis = guild.RawFeatures.Contains("MORE_EMOJI");
             this.HasPreviewEnabled = guild.RawFeatures.Contains("PREVIEW_ENABLED");
             this.CanSetVanityUrl = guild.RawFeatures.Contains("VANITY_URL");
             this.IsVerified = guild.RawFeatures.Contains("VERIFIED");
             this.CanAccessVipRegions = guild.RawFeatures.Contains("VIP_REGIONS");
             this.HasWelcomeScreenEnabled = guild.RawFeatures.Contains("WELCOME_SCREEN_ENABLED");
             this.HasTicketedEventsEnabled = guild.RawFeatures.Contains("TICKETED_EVENTS_ENABLED");
             this.HasMonetizationEnabled = guild.RawFeatures.Contains("MONETIZATION_ENABLED");
             this.CanUploadMoreStickers = guild.RawFeatures.Contains("MORE_STICKERS");
             this.CanSetThreadArchiveDurationThreeDays = guild.RawFeatures.Contains("THREE_DAY_THREAD_ARCHIVE");
             this.CanSetThreadArchiveDurationSevenDays = guild.RawFeatures.Contains("SEVEN_DAY_THREAD_ARCHIVE");
             this.CanCreatePrivateThreads = guild.RawFeatures.Contains("PRIVATE_THREADS");
             this.IsHub = guild.RawFeatures.Contains("HUB");
             this.HasThreadTestingEnabled = guild.RawFeatures.Contains("THREADS_ENABLED_TESTING");
             this.HasThreadsEnabled = guild.RawFeatures.Contains("THREADS_ENABLED");
             this.CanSetRoleIcons = guild.RawFeatures.Contains("ROLE_ICONS");
             this.HasNewThreadPermissions = guild.RawFeatures.Contains("NEW_THREAD_PERMISSIONS");
             this.HasRoleSubscriptionsEnabled = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_ENABLED");
             this.PremiumTierThreeOverride = guild.RawFeatures.Contains("PREMIUM_TIER_3_OVERRIDE");
             this.CanSetThreadDefaultAutoArchiveDuration = guild.RawFeatures.Contains("THREAD_DEFAULT_AUTO_ARCHIVE_DURATION");
             this.TextInVoiceEnabled = guild.RawFeatures.Contains("TEXT_IN_VOICE_ENABLED");
             this.HasDirectoryEntry = guild.RawFeatures.Contains("HAS_DIRECTORY_ENTRY");
             this.IsLinkedToHub = guild.RawFeatures.Contains("LINKED_TO_HUB");
             this.HasMemberProfiles = guild.RawFeatures.Contains("MEMBER_PROFILES");
             this.IsStaffOnly = guild.RawFeatures.Contains("INTERNAL_EMPLOYEE_ONLY");
             this.RoleSubscriptionsIsAvaiableForPurchase = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE");
 
             var _features = guild.RawFeatures.Any() ? "" : "None";
             foreach (var feature in guild.RawFeatures)
             {
                 _features += feature + " ";
             }
             this.FeatureString = _features;
 
         }
     }
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
index c3b56bc3a..a239d3673 100644
--- a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
@@ -1,429 +1,429 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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; } = false;
 
         /// <summary>
         /// Gets the Allowed Mentions for the message to be sent.
         /// </summary>
         public List<IMention> Mentions { get; private set; } = null;
 
         /// <summary>
         /// Gets the Files to be sent in the Message.
         /// </summary>
         public IReadOnlyCollection<DiscordMessageFile> Files => this._files;
         internal readonly List<DiscordMessageFile> _files = new();
 
         /// <summary>
         /// Gets the components that will be attached to the message.
         /// </summary>
         public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
         internal readonly List<DiscordActionRowComponent> _components = new(5);
 
         /// <summary>
         /// Gets the Attachments to be sent in the Message.
         /// </summary>
         internal List<DiscordAttachment> Attachments { get; private set; } = null;
 
         /// <summary>
         /// Gets the Reply Message ID.
         /// </summary>
         public ulong? ReplyId { get; private set; } = null;
 
         /// <summary>
         /// Gets if the Reply should mention the user.
         /// </summary>
         public bool MentionOnReply { get; private set; } = false;
 
         /// <summary>
         /// Gets if the embeds should be suppressed.
         /// </summary>
         public bool Suppressed { get; private set; } = false;
 
         /// <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="ArgumentOutOfRangeException">No components were passed.</exception>
+        /// <exception cref="System.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._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 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="ArgumentOutOfRangeException">No components were passed.</exception>
+        /// <exception cref="System.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._components.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>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithFile(string fileName, Stream stream, bool resetStreamPosition = false)
         {
             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, stream, stream.Position));
             else
                 this._files.Add(new DiscordMessageFile(fileName, stream, null));
 
             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>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithFile(FileStream stream, bool resetStreamPosition = false)
         {
             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));
             else
                 this._files.Add(new DiscordMessageFile(stream.Name, stream, null));
 
             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._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>
         /// 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._components.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._files.Clear();
             this.ReplyId = null;
             this.MentionOnReply = false;
             this._components.Clear();
             this.Suppressed = false;
             this.Sticker = 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>
         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)
                     throw new ArgumentException("You must specify content, an embed, a sticker 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 68346e1fc..0a2a1610c 100644
--- a/DisCatSharp/Entities/Optional.cs
+++ b/DisCatSharp/Entities/Optional.cs
@@ -1,291 +1,291 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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 allow type parameter inference on calls to <see cref="FromValue{T}"/> or
     /// <see cref="FromNoValue{T}"/>.
     /// </remarks>
     public static class Optional
     {
         /// <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> FromValue<T>(T value)
             => new(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>
         public static Optional<T> FromNoValue<T>()
             => default;
     }
 
     // used internally to make serialization more convenient, do NOT change this, do NOT implement this yourself
     /// <summary>
     /// Represents a IOptional interface.
     /// </summary>
     internal interface IOptional
     {
         /// <summary>
         /// Gets a whether it has a value.
         /// </summary>
         bool HasValue { get; }
 
         /// <summary>
         /// Gets the raw value.
         /// </summary>
         object RawValue { get; } // must NOT throw InvalidOperationException
     }
 
     /// <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>
         /// 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="InvalidOperationException">If this <see cref="Optional{T}"/> has no value.</exception>
+        /// <exception cref="System.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>
         public Optional(T value)
         {
             this._val = value;
             this.HasValue = true;
         }
 
         /// <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.HasValue ? this.Value.ToString() : "<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)
         {
             return 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.HasValue ? this.Value.GetHashCode() : 0;
 
         public static implicit operator Optional<T>(T val)
             => new(val);
 
         public static explicit operator T(Optional<T> opt)
             => opt.Value;
 
         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>
         /// Performs a mapping operation on the current <see cref="Optional{T}"/>, turning it into an Optional holding a
         /// <typeparamref name="TTarget"/> 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="TTarget">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<TTarget> IfPresent<TTarget>(Func<T, TTarget> mapper) => this.HasValue ? new Optional<TTarget>(mapper(this.Value)) : default;
     }
 
     /// <summary>
     /// Represents an optional json contract resolver.
     /// <seealso cref="DiscordJson._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 f81297850..fd1d1f132 100644
--- a/DisCatSharp/Entities/Sticker/DiscordSticker.cs
+++ b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
@@ -1,216 +1,216 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.Exceptions;
 using DisCatSharp.Enums;
 using Newtonsoft.Json;
 using DisCatSharp.Net;
 
 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>
         /// Whether to stickers are equal.
         /// </summary>
         /// <param name="other">DiscordSticker</param>
         /// <returns></returns>
         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="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="DisCatSharp.Exceptions.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)
         {
             return !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="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="DisCatSharp.Exceptions.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/Thread/DiscordThreadChannel.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
index bcb7a6a4d..419628985 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
@@ -1,661 +1,661 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.Exceptions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a discord thread channel.
     /// </summary>
     public class DiscordThreadChannel : DiscordChannel, IEquatable<DiscordThreadChannel>
     {
         /// <summary>
         /// Gets ID of the owner that started this thread.
         /// </summary>
         [JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong OwnerId { get; internal set; }
 
         /// <summary>
         /// Gets the name of this thread.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public new string Name { get; internal set; }
 
         /// <summary>
         /// Gets the type of this thread.
         /// </summary>
         [JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
         public new ChannelType Type { get; internal set; }
 
         /// <summary>
         /// Gets whether this thread is private.
         /// </summary>
         [JsonIgnore]
         public new bool IsPrivate
             => this.Type == ChannelType.PrivateThread;
 
         /// <summary>
         /// Gets the ID of the last message sent in this thread.
         /// </summary>
         [JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
         public new ulong? LastMessageId { get; internal set; }
 
         /// <summary>
         /// <para>Gets the slowmode delay configured for this thread.</para>
         /// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slowmode.</para>
         /// </summary>
         [JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
         public new int? PerUserRateLimit { get; internal set; }
 
         /// <summary>
         /// Gets an approximate count of messages in a thread, stops counting at 50.
         /// </summary>
         [JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? MessageCount { get; internal set; }
 
         /// <summary>
         /// Gets an approximate count of users in a thread, stops counting at 50.
         /// </summary>
         [JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? MemberCount { get; internal set; }
 
         /// <summary>
         /// Represents the current member for this thread. This will have a value if the user has joined the thread.
         /// </summary>
         [JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordThreadChannelMember CurrentMember { get; internal set; }
 
 
         /// <summary>
         /// Gets when the last pinned message was pinned in this thread.
         /// </summary>
         [JsonIgnore]
         public new DateTimeOffset? LastPinTimestamp
             => !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
                 dto : null;
 
         /// <summary>
         /// Gets when the last pinned message was pinned in this thread as raw string.
         /// </summary>
         [JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
         internal new string LastPinTimestampRaw { get; set; }
 
         /// <summary>
         /// Gets the threads metadata.
         /// </summary>
         [JsonProperty("thread_metadata", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordThreadChannelMetadata ThreadMetadata { get; internal set; }
 
         /// <summary>
         /// Gets the thread members object.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordThreadChannelMember> ThreadMembers => new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannelMember>(this._threadMembers);
 
         [JsonProperty("thread_member", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordThreadChannelMember> _threadMembers;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
         /// </summary>
         internal DiscordThreadChannel() { }
 
         #region Methods
 
         /// <summary>
         /// Deletes a thread.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task DeleteAsync(string reason = null)
             => this.Discord.ApiClient.DeleteThreadAsync(this.Id, reason);
 
 
         /// <summary>
         /// Modifies the current thread.
         /// </summary>
         /// <param name="action">Action to perform on this thread</param>
         /// <exception cref="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="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="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 can_continue = !mdl.AutoArchiveDuration.HasValue || !mdl.AutoArchiveDuration.Value.HasValue || Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.AutoArchiveDuration.Value.Value);
             if (mdl.Invitable.HasValue)
             {
                 can_continue = this.Guild.Features.CanCreatePrivateThreads;
             }
             return can_continue ? this.Discord.ApiClient.ModifyThreadAsync(this.Id, mdl.Name, mdl.Locked, mdl.Archived, mdl.AutoArchiveDuration, mdl.PerUserRateLimit, mdl.Invitable, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(mdl.AutoArchiveDuration.Value.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
         }
 
         /// <summary>
         /// Archives a thread.
         /// </summary>
         /// <param name="locked">Whether the thread should be locked.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ArchiveAsync(bool locked = true, string reason = null)
             => this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, locked, true, null, null, null, reason: reason);
 
         /// <summary>
         /// Unarchives a thread.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnarchiveAsync(string reason = null)
             => this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, null, false, null, null, null, reason: reason);
 
         /// <summary>
         /// Gets the members of a thread. Needs the <see cref="DiscordIntents.GuildMembers"/> intent.
         /// </summary>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordThreadChannelMember>> GetMembersAsync()
             => await this.Discord.ApiClient.GetThreadMembersAsync(this.Id);
 
         /// <summary>
         /// Adds a member to this thread.
         /// </summary>
         /// <param name="member_id">The member id to be added.</param>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddMemberAsync(ulong member_id)
             => this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member_id);
 
         /// <summary>
         /// Adds a member to this thread.
         /// </summary>
         /// <param name="member">The member to be added.</param>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddMemberAsync(DiscordMember member)
             => this.AddMemberAsync(member.Id);
 
         /// <summary>
         /// Gets a member in this thread.
         /// </summary>
         /// <param name="member_id">The member to be added.</param>
-        /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordThreadChannelMember> GetMemberAsync(ulong member_id)
             => this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member_id);
 
         /// <summary>
         /// Gets a member in this thread.
         /// </summary>
         /// <param name="member">The member to be added.</param>
-        /// <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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordThreadChannelMember> GetMemberAsync(DiscordMember member)
             => this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member.Id);
 
         /// <summary>
         /// Removes a member from this thread.
         /// </summary>
         /// <param name="member_id">The member id to be removed.</param>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveMemberAsync(ulong member_id)
             => this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member_id);
 
         /// <summary>
         /// Removes a member from this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="member">The member to be removed.</param>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveMemberAsync(DiscordMember member)
             => this.RemoveMemberAsync(member.Id);
 
         /// <summary>
         /// Adds a role to this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role_id">The role id to be added.</param>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task AddRoleAsync(ulong role_id)
         {
             var role = this.Guild.GetRole(role_id);
             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="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddRoleAsync(DiscordRole role)
             => this.AddRoleAsync(role.Id);
 
         /// <summary>
         /// Removes a role from this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role_id">The role id to be removed.</param>
-        /// <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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task RemoveRoleAsync(ulong role_id)
         {
             var role = this.Guild.GetRole(role_id);
             var members = await this.Guild.GetAllMembersAsync();
             var roleMembers = members.Where(m => m.Roles.Contains(role));
             foreach (var member in roleMembers)
             {
                 await this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member.Id);
             }
         }
 
         /// <summary>
         /// Removes a role to from thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role">The role to be removed.</param>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveRoleAsync(DiscordRole role)
             => this.RemoveRoleAsync(role.Id);
 
         /// <summary>
         /// Joins a thread.
         /// </summary>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task JoinAsync()
             => this.Discord.ApiClient.JoinThreadAsync(this.Id);
 
         /// <summary>
         /// Leaves a thread.
         /// </summary>
         /// <exception cref="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>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task LeaveAsync()
             => this.Discord.ApiClient.LeaveThreadAsync(this.Id);
 
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<DiscordMessage> SendMessageAsync(string content)
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, null, new[] {embed}, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
         {
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, new[] {embed}, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="builder">The builder with all the items to thread.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
             => this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="action">The builder with all the items to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
 
             return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
         }
 
         /// <summary>
         /// Returns a specific message
         /// </summary>
         /// <param name="id">The id of the message</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new async Task<DiscordMessage> GetMessageAsync(ulong id)
         {
             return this.Discord.Configuration.MessageCacheSize > 0
                 && this.Discord is DiscordClient dc
                 && dc.MessageCache != null
                 && dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
                 ? msg
                 : await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a list of messages before a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="before">Message to fetch before from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
             => this.GetMessagesInternalAsync(limit, before, null, null);
 
         /// <summary>
         /// Returns a list of messages after a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="after">Message to fetch after from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, after, null);
 
         /// <summary>
         /// Returns a list of messages around a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="around">Message to fetch around from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, null, around);
 
         /// <summary>
         /// Returns a list of messages from the last message in the thread.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
             this.GetMessagesInternalAsync(limit, null, null, null);
 
         /// <summary>
         /// Returns a list of messages
         /// </summary>
         /// <param name="limit">How many messages should be returned.</param>
         /// <param name="before">Get messages before snowflake.</param>
         /// <param name="after">Get messages after snowflake.</param>
         /// <param name="around">Get messages around snowflake.</param>
         private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
         {
             if (this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread)
                 throw new ArgumentException("Cannot get the messages of a non-thread channel.");
 
             if (limit < 0)
                 throw new ArgumentException("Cannot get a negative number of messages.");
 
             if (limit == 0)
                 return Array.Empty<DiscordMessage>();
 
             //return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
             if (limit > 100 && around != null)
                 throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
             var msgs = new List<DiscordMessage>(limit);
             var remaining = limit;
             ulong? last = null;
             var isAfter = after != null;
 
             int lastCount;
             do
             {
                 var fetchSize = remaining > 100 ? 100 : remaining;
                 var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
                 lastCount = fetch.Count;
                 remaining -= lastCount;
 
                 if (!isAfter)
                 {
                     msgs.AddRange(fetch);
                     last = fetch.LastOrDefault()?.Id;
                 }
                 else
                 {
                     msgs.InsertRange(0, fetch);
                     last = fetch.FirstOrDefault()?.Id;
                 }
             }
             while (remaining > 0 && lastCount > 0);
 
             return new ReadOnlyCollection<DiscordMessage>(msgs);
         }
 
         /// <summary>
-        /// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="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="DisCatSharp.Exceptions.BadRequestException"/> error.
         /// </summary>
         /// <param name="messages">A collection of messages to delete.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
         {
             // don't enumerate more than once
             var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
             if (messages == null || !msgs.Any())
                 throw new ArgumentException("You need to specify at least one message to delete.");
 
             if (msgs.Count() < 2)
             {
                 await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
                 return;
             }
 
             for (var i = 0; i < msgs.Count(); i += 100)
                 await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a message
         /// </summary>
         /// <param name="message">The message to be deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
-        /// <exception cref="NotFoundException">Thrown when the 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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task DeleteMessageAsync(DiscordMessage message, string reason = null)
             => this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 
         /// <summary>
         /// Post a typing indicator
         /// </summary>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task TriggerTypingAsync()
         {
             return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
                 ? throw new ArgumentException("Cannot start typing in a non-text channel.")
                 : this.Discord.ApiClient.TriggerTypingAsync(this.Id);
         }
 
         /// <summary>
         /// Returns all pinned messages
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission or the client is missing <see cref="Permissions.ReadMessageHistory"/>.</exception>
-        /// <exception cref="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public new Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync()
         {
             return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread&& this.Type != ChannelType.News
                 ? throw new ArgumentException("A non-thread channel does not have pinned messages.")
                 : this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
         }
 
         /// <summary>
         /// Returns a string representation of this thread.
         /// </summary>
         /// <returns>String representation of this thread.</returns>
         public override string ToString()
         {
             var threadchannel = (object)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})",
             };
             return threadchannel;
         }
         #endregion
 
         /// <summary>
         /// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordThreadChannel"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannel);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannel"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannel"/>.</returns>
         public bool Equals(DiscordThreadChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordThreadChannel"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordThreadChannel"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are equal.</returns>
         public static bool operator ==(DiscordThreadChannel e1, DiscordThreadChannel e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordThreadChannel"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are not equal.</returns>
         public static bool operator !=(DiscordThreadChannel e1, DiscordThreadChannel e2)
             => !(e1 == e2);
     }
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
index 1b0384b24..44161710a 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
@@ -1,413 +1,413 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Constructs ready-to-send webhook requests.
     /// </summary>
     public sealed class DiscordWebhookBuilder
     {
         /// <summary>
         /// Username to use for this webhook request.
         /// </summary>
         public Optional<string> Username { get; set; }
 
         /// <summary>
         /// Avatar url to use for this webhook request.
         /// </summary>
         public Optional<string> AvatarUrl { get; set; }
 
         /// <summary>
         /// Whether this webhook request is text-to-speech.
         /// </summary>
         public bool IsTTS { get; set; }
 
         /// <summary>
         /// Message to send on this webhook request.
         /// </summary>
         public string Content
         {
             get => this._content;
             set
             {
                 if (value != null && value.Length > 2000)
                     throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
                 this._content = value;
             }
         }
         private string _content;
 
         /// <summary>
         /// 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 { get; }
         private readonly List<DiscordAttachment> _attachments = 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="ArgumentOutOfRangeException">No components were passed.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
         public DiscordWebhookBuilder AddComponents(params DiscordComponent[] components)
             => this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
         /// <summary>
         /// Appends several rows of components to the builder
         /// </summary>
         /// <param name="components">The rows of components to add, holding up to five each.</param>
         /// <returns></returns>
         public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
         {
             var ara = components.ToArray();
 
             if (ara.Length + this._components.Count > 5)
                 throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
             foreach (var ar in ara)
                 this._components.Add(ar);
 
             return this;
         }
 
         /// <summary>
         /// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
         /// </summary>
         /// <param name="components">The components to add to the builder.</param>
         /// <returns>The current builder to be chained.</returns>
-        /// <exception cref="ArgumentOutOfRangeException">No components were passed.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
         public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordComponent> components)
         {
             var cmpArr = components.ToArray();
             var count = cmpArr.Length;
 
             if (!cmpArr.Any())
                 throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
             if (count > 5)
                 throw new ArgumentException("Cannot add more than 5 components per action row!");
 
             var comp = new DiscordActionRowComponent(cmpArr);
             this._components.Add(comp);
 
             return this;
         }
 
         /// <summary>
         /// Sets the username for this webhook builder.
         /// </summary>
         /// <param name="username">Username of the webhook</param>
         public DiscordWebhookBuilder WithUsername(string username)
         {
             this.Username = username;
             return this;
         }
 
         /// <summary>
         /// Sets the avatar of this webhook builder from its url.
         /// </summary>
         /// <param name="avatarUrl">Avatar url of the webhook</param>
         public DiscordWebhookBuilder WithAvatarUrl(string avatarUrl)
         {
             this.AvatarUrl = avatarUrl;
             return this;
         }
 
         /// <summary>
         /// Indicates if the webhook must use text-to-speech.
         /// </summary>
         /// <param name="tts">Text-to-speech</param>
         public DiscordWebhookBuilder WithTTS(bool tts)
         {
             this.IsTTS = tts;
             return this;
         }
 
         /// <summary>
         /// Sets the message to send at the execution of the webhook.
         /// </summary>
         /// <param name="content">Message to send.</param>
         public DiscordWebhookBuilder WithContent(string content)
         {
             this.Content = content;
             return this;
         }
 
         /// <summary>
         /// 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>
         public DiscordWebhookBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false)
         {
             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));
             else
                 this._files.Add(new DiscordMessageFile(filename, data, null));
 
             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>
         /// <returns></returns>
         public DiscordWebhookBuilder AddFile(FileStream stream, bool resetStreamPosition = false)
         {
             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));
             else
                 this._files.Add(new DiscordMessageFile(stream.Name, stream, null));
 
             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>
         /// 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._attachments.Clear();
             this._components.Clear();
         }
 
         /// <summary>
         /// Does the validation before we send a the Create/Modify request.
         /// </summary>
         /// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
         /// <param name="isFollowup">Tells the method to perform the follow up message validation.</param>
         /// <param name="isInteractionResponse">Tells the method to perform the interaction response validation.</param>
         internal void Validate(bool isModify = false, bool isFollowup = false, bool isInteractionResponse = false)
         {
             if (isModify)
             {
                 if (this.Username.HasValue)
                     throw new ArgumentException("You cannot change the username of a message.");
 
                 if (this.AvatarUrl.HasValue)
                     throw new ArgumentException("You cannot change the avatar of a message.");
             }
             else if (isFollowup)
             {
                 if (this.Username.HasValue)
                     throw new ArgumentException("You cannot change the username of a follow up message.");
 
                 if (this.AvatarUrl.HasValue)
                     throw new ArgumentException("You cannot change the avatar of a follow up message.");
             }
             else if (isInteractionResponse)
             {
                 if (this.Username.HasValue)
                     throw new ArgumentException("You cannot change the username of an interaction response.");
 
                 if (this.AvatarUrl.HasValue)
                     throw new ArgumentException("You cannot change the avatar of an interaction response.");
             }
             else
             {
                 if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && !this.Embeds.Any())
                     throw new ArgumentException("You must specify content, an embed, or at least one file.");
             }
         }
     }
 }
diff --git a/DisCatSharp/Exceptions/BadRequestException.cs b/DisCatSharp/Exceptions/BadRequestException.cs
index 9ad2c6f66..32b2db4f7 100644
--- a/DisCatSharp/Exceptions/BadRequestException.cs
+++ b/DisCatSharp/Exceptions/BadRequestException.cs
@@ -1,85 +1,85 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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="BadRequestException"/> class.
+        /// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.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 8ad767ff7..f9483090d 100644
--- a/DisCatSharp/Exceptions/NotFoundException.cs
+++ b/DisCatSharp/Exceptions/NotFoundException.cs
@@ -1,69 +1,69 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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="NotFoundException"/> class.
+        /// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.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 18ab76225..c1b9826a1 100644
--- a/DisCatSharp/Exceptions/ServerErrorException.cs
+++ b/DisCatSharp/Exceptions/ServerErrorException.cs
@@ -1,69 +1,69 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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="ServerErrorException"/> class.
+        /// Initializes a new instance of the <see cref="DisCatSharp.Exceptions.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/RingBuffer.cs b/DisCatSharp/RingBuffer.cs
index b0a4dd9ec..8e4e35a0e 100644
--- a/DisCatSharp/RingBuffer.cs
+++ b/DisCatSharp/RingBuffer.cs
@@ -1,241 +1,241 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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;
 
 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._reached_end ? 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 _reached_end = false;
 
         /// <summary>
         /// Creates a new ring buffer with specified size.
         /// </summary>
         /// <param name="size">Size of the buffer to create.</param>
-        /// <exception cref="ArgumentOutOfRangeException" />
+        /// <exception cref="System.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="ArgumentException" />
-        /// <exception cref="ArgumentOutOfRangeException" />
+        /// <exception cref="System.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="ArgumentException" />
-        /// <exception cref="ArgumentOutOfRangeException" />
+        /// <exception cref="System.ArgumentOutOfRangeException" />
         public RingBuffer(IEnumerable<T> elements, int index)
         {
             if (elements == null || !elements.Any())
                 throw new ArgumentException(nameof(elements), "The collection cannot be null or empty.");
 
             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._reached_end = 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()
         {
             for (var i = 0; i < this.InternalBuffer.Length; i++)
                 this.InternalBuffer[i] = 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="NotImplementedException" />
+        /// <exception cref="System.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()
         {
             return !this._reached_end
                 ? 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 8edad5646..e7664c2de 100644
--- a/DisCatSharp/Utilities.cs
+++ b/DisCatSharp/Utilities.cs
@@ -1,465 +1,465 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 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.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>
         internal static UTF8Encoding UTF8 { get; } = new UTF8Encoding(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)
         {
             return config.TokenType switch
             {
                 TokenType.Bearer => $"Bearer {config.Token}",
                 TokenType.Bot => $"Bot {config.Token}",
                 _ => throw new ArgumentException("Invalid token type specified.", nameof(config.Token)),
             };
         }
 
         /// <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);
             foreach (Match match in matches)
                 yield return 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);
             foreach (Match match in matches)
                 yield return 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);
             foreach (Match match in matches)
                 yield return 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);
             foreach (Match match in matches)
                 yield return 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}$", RegexOptions.ECMAScript);
             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)
         {
             return taad == ThreadAutoArchiveDuration.ThreeDays
                 ? (guild.PremiumTier.HasFlag(PremiumTier.TierOne) || guild.Features.CanSetThreadArchiveDurationThreeDays)
                 : taad != ThreadAutoArchiveDuration.OneWeek || guild.PremiumTier.HasFlag(PremiumTier.TierTwo) || guild.Features.CanSetThreadArchiveDurationSevenDays;
         }
 
         /// <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 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="DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
+        /// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
         /// </summary>
         /// <param name="unixTime">Unix time seconds to convert.</param>
         /// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
-        /// <returns>Calculated <see cref="DateTimeOffset"/>.</returns>
+        /// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
         public static DateTimeOffset GetDateTimeOffset(long unixTime, bool shouldThrow = true)
         {
             try
             {
                 return DateTimeOffset.FromUnixTimeSeconds(unixTime);
             }
             catch (Exception)
             {
                 if (shouldThrow)
                     throw;
 
                 return DateTimeOffset.MinValue;
             }
         }
 
         /// <summary>
-        /// Helper method to create a <see cref="DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
+        /// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
         /// </summary>
         /// <param name="unixTime">Unix time milliseconds to convert.</param>
         /// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
-        /// <returns>Calculated <see cref="DateTimeOffset"/>.</returns>
+        /// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
         public static DateTimeOffset GetDateTimeOffsetFromMilliseconds(long unixTime, bool shouldThrow = true)
         {
             try
             {
                 return DateTimeOffset.FromUnixTimeMilliseconds(unixTime);
             }
             catch (Exception)
             {
                 if (shouldThrow)
                     throw;
 
                 return DateTimeOffset.MinValue;
             }
         }
 
         /// <summary>
-        /// Helper method to calculate Unix time seconds from a <see cref="DateTimeOffset"/> for targets that do not support this natively.
+        /// Helper method to calculate Unix time seconds from a <see cref="System.DateTimeOffset"/> for targets that do not support this natively.
         /// </summary>
-        /// <param name="dto"><see cref="DateTimeOffset"/> to calculate Unix time for.</param>
+        /// <param name="dto"><see cref="System.DateTimeOffset"/> to calculate Unix time for.</param>
         /// <returns>Calculated Unix time.</returns>
         public static long GetUnixTime(DateTimeOffset dto)
             => dto.ToUnixTimeMilliseconds();
 
         /// <summary>
         /// Computes a timestamp from a given snowflake.
         /// </summary>
         /// <param name="snowflake">Snowflake to compute a timestamp from.</param>
         /// <returns>Computed timestamp.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static DateTimeOffset GetSnowflakeTime(this ulong snowflake)
             => DiscordClient._discordEpoch.AddMilliseconds(snowflake >> 22);
 
         /// <summary>
         /// Converts this <see cref="Permissions"/> into human-readable format.
         /// </summary>
         /// <param name="perm">Permissions enumeration to convert.</param>
         /// <returns>Human-readable permissions.</returns>
         public static string ToPermissionString(this Permissions perm)
         {
             if (perm == Permissions.None)
                 return PermissionStrings[perm];
 
             perm &= PermissionMethods.FULL_PERMS;
 
             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;
         }
     }
 }