diff --git a/DisCatSharp.CommandsNext/CommandsNextExtension.cs b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
index dc519b047..ba53c09bc 100644
--- a/DisCatSharp.CommandsNext/CommandsNextExtension.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
@@ -1,1083 +1,1085 @@
 // 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()
+                [typeof(DiscordColor)] = new DiscordColorConverter(),
+                [typeof(DiscordScheduledEvent)] = new DiscordScheduledEventConverter(),
             };
 
             this.UserFriendlyTypeNames = new Dictionary<Type, string>()
             {
                 [typeof(string)] = "string",
                 [typeof(bool)] = "boolean",
                 [typeof(sbyte)] = "signed byte",
                 [typeof(byte)] = "byte",
                 [typeof(short)] = "short",
                 [typeof(ushort)] = "unsigned short",
                 [typeof(int)] = "int",
                 [typeof(uint)] = "unsigned int",
                 [typeof(long)] = "long",
                 [typeof(ulong)] = "unsigned long",
                 [typeof(float)] = "float",
                 [typeof(double)] = "double",
                 [typeof(decimal)] = "decimal",
                 [typeof(DateTime)] = "date and time",
                 [typeof(DateTimeOffset)] = "date and time",
                 [typeof(TimeSpan)] = "time span",
                 [typeof(Uri)] = "URL",
                 [typeof(DiscordUser)] = "user",
                 [typeof(DiscordMember)] = "member",
                 [typeof(DiscordRole)] = "role",
                 [typeof(DiscordChannel)] = "channel",
                 [typeof(DiscordGuild)] = "guild",
                 [typeof(DiscordMessage)] = "message",
                 [typeof(DiscordEmoji)] = "emoji",
                 [typeof(DiscordThreadChannel)] = "thread",
                 [typeof(DiscordInvite)] = "invite",
-                [typeof(DiscordColor)] = "color"
+                [typeof(DiscordColor)] = "color",
+                [typeof(DiscordScheduledEvent)] = "event"
             };
 
             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="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.CommandsNext/CommandsNextUtilities.cs b/DisCatSharp.CommandsNext/CommandsNextUtilities.cs
index 7873c9b92..4d04b9874 100644
--- a/DisCatSharp.CommandsNext/CommandsNextUtilities.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextUtilities.cs
@@ -1,431 +1,432 @@
 // 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.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Converters;
 using DisCatSharp.Entities;
+using DisCatSharp.Common.RegularExpressions;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.CommandsNext
 {
     /// <summary>
     /// Various CommandsNext-related utilities.
     /// </summary>
     public static class CommandsNextUtilities
     {
         /// <summary>
         /// Gets the user regex.
         /// </summary>
-        private static Regex UserRegex { get; } = new Regex(@"<@\!?(\d+?)> ", RegexOptions.ECMAScript);
+        private static Regex UserRegex { get; } = DiscordRegEx.User;
 
         /// <summary>
         /// Checks whether the message has a specified string prefix.
         /// </summary>
         /// <param name="msg">Message to check.</param>
         /// <param name="str">String to check for.</param>
         /// <param name="comparisonType">Method of string comparison for the purposes of finding prefixes.</param>
         /// <returns>Positive number if the prefix is present, -1 otherwise.</returns>
         public static int GetStringPrefixLength(this DiscordMessage msg, string str, StringComparison comparisonType = StringComparison.Ordinal)
         {
             var content = msg.Content;
             return str.Length >= content.Length ? -1 : !content.StartsWith(str, comparisonType) ? -1 : str.Length;
         }
 
         /// <summary>
         /// Checks whether the message contains a specified mention prefix.
         /// </summary>
         /// <param name="msg">Message to check.</param>
         /// <param name="user">User to check for.</param>
         /// <returns>Positive number if the prefix is present, -1 otherwise.</returns>
         public static int GetMentionPrefixLength(this DiscordMessage msg, DiscordUser user)
         {
             var content = msg.Content;
             if (!content.StartsWith("<@"))
                 return -1;
 
             var cni = content.IndexOf('>');
             if (cni == -1 || content.Length <= cni + 2)
                 return -1;
 
             var cnp = content.Substring(0, cni + 2);
             var m = UserRegex.Match(cnp);
             if (!m.Success)
                 return -1;
 
             var userId = ulong.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture);
             return user.Id != userId ? -1 : m.Value.Length;
         }
 
         //internal static string ExtractNextArgument(string str, out string remainder)
         /// <summary>
         /// Extracts the next argument.
         /// </summary>
         /// <param name="str">The string.</param>
         /// <param name="startPos">The start position.</param>
         internal static string ExtractNextArgument(this string str, ref int startPos)
         {
             if (string.IsNullOrWhiteSpace(str))
                 return null;
 
             var inBacktick = false;
             var inTripleBacktick = false;
             var inQuote = false;
             var inEscape = false;
             var removeIndices = new List<int>(str.Length - startPos);
 
             var i = startPos;
             for (; i < str.Length; i++)
                 if (!char.IsWhiteSpace(str[i]))
                     break;
             startPos = i;
 
             var endPosition = -1;
             var startPosition = startPos;
             for (i = startPosition; i < str.Length; i++)
             {
                 if (char.IsWhiteSpace(str[i]) && !inQuote && !inTripleBacktick && !inBacktick && !inEscape)
                     endPosition = i;
 
                 if (str[i] == '\\' && str.Length > i + 1)
                 {
                     if (!inEscape && !inBacktick && !inTripleBacktick)
                     {
                         inEscape = true;
                         if (str.IndexOf("\\`", i) == i || str.IndexOf("\\\"", i) == i || str.IndexOf("\\\\", i) == i || (str.Length >= i && char.IsWhiteSpace(str[i + 1])))
                             removeIndices.Add(i - startPosition);
                         i++;
                     }
                     else if ((inBacktick || inTripleBacktick) && str.IndexOf("\\`", i) == i)
                     {
                         inEscape = true;
                         removeIndices.Add(i - startPosition);
                         i++;
                     }
                 }
 
                 if (str[i] == '`' && !inEscape)
                 {
                     var tripleBacktick = str.IndexOf("```", i) == i;
                     if (inTripleBacktick && tripleBacktick)
                     {
                         inTripleBacktick = false;
                         i += 2;
                     }
                     else if (!inBacktick && tripleBacktick)
                     {
                         inTripleBacktick = true;
                         i += 2;
                     }
 
                     if (inBacktick && !tripleBacktick)
                         inBacktick = false;
                     else if (!inTripleBacktick && tripleBacktick)
                         inBacktick = true;
                 }
 
                 if (str[i] == '"' && !inEscape && !inBacktick && !inTripleBacktick)
                 {
                     removeIndices.Add(i - startPosition);
 
                     inQuote = !inQuote;
                 }
 
                 if (inEscape)
                     inEscape = false;
 
                 if (endPosition != -1)
                 {
                     startPos = endPosition;
                     return startPosition != endPosition ? str.Substring(startPosition, endPosition - startPosition).CleanupString(removeIndices) : null;
                 }
             }
 
             startPos = str.Length;
             return startPos != startPosition ? str.Substring(startPosition).CleanupString(removeIndices) : null;
         }
 
         /// <summary>
         /// Cleanups the string.
         /// </summary>
         /// <param name="s">The string.</param>
         /// <param name="indices">The indices.</param>
         internal static string CleanupString(this string s, IList<int> indices)
         {
             if (!indices.Any())
                 return s;
 
             var li = indices.Last();
             var ll = 1;
             for (var x = indices.Count - 2; x >= 0; x--)
             {
                 if (li - indices[x] == ll)
                 {
                     ll++;
                     continue;
                 }
 
                 s = s.Remove(li - ll + 1, ll);
                 li = indices[x];
                 ll = 1;
             }
 
             return s.Remove(li - ll + 1, ll);
         }
 
 #pragma warning disable IDE1006 // Naming Styles
         /// <summary>
         /// Binds the arguments.
         /// </summary>
         /// <param name="ctx">The command context.</param>
         /// <param name="ignoreSurplus">If true, ignore further text in string.</param>
         internal static async Task<ArgumentBindingResult> BindArguments(CommandContext ctx, bool ignoreSurplus)
 #pragma warning restore IDE1006 // Naming Styles
         {
             var command = ctx.Command;
             var overload = ctx.Overload;
 
             var args = new object[overload.Arguments.Count + 2];
             args[1] = ctx;
             var rawArgumentList = new List<string>(overload.Arguments.Count);
 
             var argString = ctx.RawArgumentString;
             var foundAt = 0;
             var argValue = "";
             for (var i = 0; i < overload.Arguments.Count; i++)
             {
                 var arg = overload.Arguments[i];
                 if (arg.IsCatchAll)
                 {
                     if (arg.IsArray)
                     {
                         while (true)
                         {
                             argValue = ExtractNextArgument(argString, ref foundAt);
                             if (argValue == null)
                                 break;
 
                             rawArgumentList.Add(argValue);
                         }
 
                         break;
                     }
                     else
                     {
                         if (argString == null)
                             break;
 
                         argValue = argString.Substring(foundAt).Trim();
                         argValue = argValue == "" ? null : argValue;
                         foundAt = argString.Length;
 
                         rawArgumentList.Add(argValue);
                         break;
                     }
                 }
                 else
                 {
                     argValue = ExtractNextArgument(argString, ref foundAt);
                     rawArgumentList.Add(argValue);
                 }
 
                 if (argValue == null && !arg.IsOptional && !arg.IsCatchAll)
                     return new ArgumentBindingResult(new ArgumentException("Not enough arguments supplied to the command."));
                 else if (argValue == null)
                     rawArgumentList.Add(null);
             }
 
             if (!ignoreSurplus && foundAt < argString.Length)
                 return new ArgumentBindingResult(new ArgumentException("Too many arguments were supplied to this command."));
 
             for (var i = 0; i < overload.Arguments.Count; i++)
             {
                 var arg = overload.Arguments[i];
                 if (arg.IsCatchAll && arg.IsArray)
                 {
                     var array = Array.CreateInstance(arg.Type, rawArgumentList.Count - i);
                     var start = i;
                     while (i < rawArgumentList.Count)
                     {
                         try
                         {
                             array.SetValue(await ctx.CommandsNext.ConvertArgument(rawArgumentList[i], ctx, arg.Type).ConfigureAwait(false), i - start);
                         }
                         catch (Exception ex)
                         {
                             return new ArgumentBindingResult(ex);
                         }
                         i++;
                     }
 
                     args[start + 2] = array;
                     break;
                 }
                 else
                 {
                     try
                     {
                         args[i + 2] = rawArgumentList[i] != null ? await ctx.CommandsNext.ConvertArgument(rawArgumentList[i], ctx, arg.Type).ConfigureAwait(false) : arg.DefaultValue;
                     }
                     catch (Exception ex)
                     {
                         return new ArgumentBindingResult(ex);
                     }
                 }
             }
 
             return new ArgumentBindingResult(args, rawArgumentList);
         }
 
         /// <summary>
         /// Whether this module is a candidate type.
         /// </summary>
         /// <param name="type">The type.</param>
         internal static bool IsModuleCandidateType(this Type type)
             => type.GetTypeInfo().IsModuleCandidateType();
 
         /// <summary>
         /// Whether this module is a candidate type.
         /// </summary>
         /// <param name="ti">The type info.</param>
         internal static bool IsModuleCandidateType(this TypeInfo ti)
         {
             // check if compiler-generated
             if (ti.GetCustomAttribute<CompilerGeneratedAttribute>(false) != null)
                 return false;
 
             // check if derives from the required base class
             var tmodule = typeof(BaseCommandModule);
             var timodule = tmodule.GetTypeInfo();
             if (!timodule.IsAssignableFrom(ti))
                 return false;
 
             // check if anonymous
             if (ti.IsGenericType && ti.Name.Contains("AnonymousType") && (ti.Name.StartsWith("<>") || ti.Name.StartsWith("VB$")) && (ti.Attributes & TypeAttributes.NotPublic) == TypeAttributes.NotPublic)
                 return false;
 
             // check if abstract, static, or not a class
             if (!ti.IsClass || ti.IsAbstract)
                 return false;
 
             // check if delegate type
             var tdelegate = typeof(Delegate).GetTypeInfo();
             if (tdelegate.IsAssignableFrom(ti))
                 return false;
 
             // qualifies if any method or type qualifies
             return ti.DeclaredMethods.Any(xmi => xmi.IsCommandCandidate(out _)) || ti.DeclaredNestedTypes.Any(xti => xti.IsModuleCandidateType());
         }
 
         /// <summary>
         /// Whether this is a command candidate.
         /// </summary>
         /// <param name="method">The method.</param>
         /// <param name="parameters">The parameters.</param>
         internal static bool IsCommandCandidate(this MethodInfo method, out ParameterInfo[] parameters)
         {
             parameters = null;
             // check if exists
             if (method == null)
                 return false;
 
             // check if static, non-public, abstract, a constructor, or a special name
             if (method.IsStatic || method.IsAbstract || method.IsConstructor || method.IsSpecialName)
                 return false;
 
             // check if appropriate return and arguments
             parameters = method.GetParameters();
             if (!parameters.Any() || parameters.First().ParameterType != typeof(CommandContext) || method.ReturnType != typeof(Task))
                 return false;
 
             // qualifies
             return true;
         }
 
         /// <summary>
         /// Creates the instance.
         /// </summary>
         /// <param name="t">The type.</param>
         /// <param name="services">The services provider.</param>
         internal static object CreateInstance(this Type t, IServiceProvider services)
         {
             var ti = t.GetTypeInfo();
             var constructors = ti.DeclaredConstructors
                 .Where(xci => xci.IsPublic)
                 .ToArray();
 
             if (constructors.Length != 1)
                 throw new ArgumentException("Specified type does not contain a public constructor or contains more than one public constructor.");
 
             var constructor = constructors[0];
             var constructorArgs = constructor.GetParameters();
             var args = new object[constructorArgs.Length];
 
             if (constructorArgs.Length != 0 && services == null)
                 throw new InvalidOperationException("Dependency collection needs to be specified for parameterized constructors.");
 
             // inject via constructor
             if (constructorArgs.Length != 0)
                 for (var i = 0; i < args.Length; i++)
                     args[i] = services.GetRequiredService(constructorArgs[i].ParameterType);
 
             var moduleInstance = Activator.CreateInstance(t, args);
 
             // inject into properties
             var props = t.GetRuntimeProperties().Where(xp => xp.CanWrite && xp.SetMethod != null && !xp.SetMethod.IsStatic && xp.SetMethod.IsPublic);
             foreach (var prop in props)
             {
                 if (prop.GetCustomAttribute<DontInjectAttribute>() != null)
                     continue;
 
                 var service = services.GetService(prop.PropertyType);
                 if (service == null)
                     continue;
 
                 prop.SetValue(moduleInstance, service);
             }
 
             // inject into fields
             var fields = t.GetRuntimeFields().Where(xf => !xf.IsInitOnly && !xf.IsStatic && xf.IsPublic);
             foreach (var field in fields)
             {
                 if (field.GetCustomAttribute<DontInjectAttribute>() != null)
                     continue;
 
                 var service = services.GetService(field.FieldType);
                 if (service == null)
                     continue;
 
                 field.SetValue(moduleInstance, service);
             }
 
             return moduleInstance;
         }
     }
 }
diff --git a/DisCatSharp.CommandsNext/Converters/EntityConverters.cs b/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
index 669686b2a..7f65ec12c 100644
--- a/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
@@ -1,578 +1,600 @@
 // 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.Text.RegularExpressions;
 using System.Threading.Tasks;
+using DisCatSharp.Common.RegularExpressions;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
     /// <summary>
     /// Represents a discord user converter.
     /// </summary>
     public class DiscordUserConverter : IArgumentConverter<DiscordUser>
     {
         /// <summary>
         /// Gets the user regex.
         /// </summary>
         private static Regex UserRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordUserConverter"/> class.
         /// </summary>
         static DiscordUserConverter()
         {
-#if NETSTANDARD1_3
-            UserRegex = new Regex(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript);
-#else
-            UserRegex = new Regex(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            UserRegex = DiscordRegEx.User;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordUser>> IArgumentConverter<DiscordUser>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var uid))
             {
                 var result = await ctx.Client.GetUserAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordUser>();
                 return ret;
             }
 
             var m = UserRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out uid))
             {
                 var result = await ctx.Client.GetUserAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordUser>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var di = value.IndexOf('#');
             var un = di != -1 ? value.Substring(0, di) : value;
             var dv = di != -1 ? value.Substring(di + 1) : null;
 
             var us = ctx.Client.Guilds.Values
                 .SelectMany(xkvp => xkvp.Members.Values)
                 .Where(xm => (cs ? xm.Username : xm.Username.ToLowerInvariant()) == un && ((dv != null && xm.Discriminator == dv) || dv == null));
 
             var usr = us.FirstOrDefault();
             return usr != null ? Optional.FromValue<DiscordUser>(usr) : Optional.FromNoValue<DiscordUser>();
         }
     }
 
     /// <summary>
     /// Represents a discord member converter.
     /// </summary>
     public class DiscordMemberConverter : IArgumentConverter<DiscordMember>
     {
         /// <summary>
         /// Gets the user regex.
         /// </summary>
         private static Regex UserRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMemberConverter"/> class.
         /// </summary>
         static DiscordMemberConverter()
         {
-#if NETSTANDARD1_3
-            UserRegex = new Regex(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript);
-#else
-            UserRegex = new Regex(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            UserRegex = DiscordRegEx.User;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordMember>> IArgumentConverter<DiscordMember>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ctx.Guild == null)
                 return Optional.FromNoValue<DiscordMember>();
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var uid))
             {
                 var result = await ctx.Guild.GetMemberAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordMember>();
                 return ret;
             }
 
             var m = UserRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out uid))
             {
                 var result = await ctx.Guild.GetMemberAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordMember>();
                 return ret;
             }
 
             var searchResult = await ctx.Guild.SearchMembersAsync(value).ConfigureAwait(false);
             if (searchResult.Any())
                 return Optional.FromValue(searchResult.First());
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var di = value.IndexOf('#');
             var un = di != -1 ? value.Substring(0, di) : value;
             var dv = di != -1 ? value.Substring(di + 1) : null;
 
             var us = ctx.Guild.Members.Values
                 .Where(xm => ((cs ? xm.Username : xm.Username.ToLowerInvariant()) == un && ((dv != null && xm.Discriminator == dv) || dv == null))
                           || (cs ? xm.Nickname : xm.Nickname?.ToLowerInvariant()) == value);
 
             var mbr = us.FirstOrDefault();
             return mbr != null ? Optional.FromValue(mbr) : Optional.FromNoValue<DiscordMember>();
         }
     }
 
     /// <summary>
     /// Represents a discord channel converter.
     /// </summary>
     public class DiscordChannelConverter : IArgumentConverter<DiscordChannel>
     {
         /// <summary>
         /// Gets the channel regex.
         /// </summary>
         private static Regex ChannelRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordChannelConverter"/> class.
         /// </summary>
         static DiscordChannelConverter()
         {
-#if NETSTANDARD1_3
-            ChannelRegex = new Regex(@"^<#(\d+)>$", RegexOptions.ECMAScript);
-#else
-            ChannelRegex = new Regex(@"^<#(\d+)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            ChannelRegex = DiscordRegEx.Channel;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordChannel>> IArgumentConverter<DiscordChannel>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var cid))
             {
                 var result = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordChannel>();
                 return ret;
             }
 
             var m = ChannelRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out cid))
             {
                 var result = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordChannel>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var chn = ctx.Guild?.Channels.Values.FirstOrDefault(xc => (cs ? xc.Name : xc.Name.ToLowerInvariant()) == value);
             return chn != null ? Optional.FromValue(chn) : Optional.FromNoValue<DiscordChannel>();
         }
     }
 
     /// <summary>
     /// Represents a discord thread channel converter.
     /// </summary>
     public class DiscordThreadChannelConverter : IArgumentConverter<DiscordThreadChannel>
     {
         /// <summary>
         /// Gets the channel regex.
         /// </summary>
         private static Regex ChannelRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordThreadChannelConverter"/> class.
         /// </summary>
         static DiscordThreadChannelConverter()
         {
-#if NETSTANDARD1_3
-            ChannelRegex = new Regex(@"^<#(\d+)>$", RegexOptions.ECMAScript);
-#else
-            ChannelRegex = new Regex(@"^<#(\d+)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            ChannelRegex = DiscordRegEx.Channel;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordThreadChannel>> IArgumentConverter<DiscordThreadChannel>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var tid))
             {
                 var result = await ctx.Client.GetThreadAsync(tid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordThreadChannel>();
                 return ret;
             }
 
             var m = ChannelRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid))
             {
                 var result = await ctx.Client.GetThreadAsync(tid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordThreadChannel>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var tchn = ctx.Guild?.Threads.Values.FirstOrDefault(xc => (cs ? xc.Name : xc.Name.ToLowerInvariant()) == value);
             return tchn != null ? Optional.FromValue(tchn) : Optional.FromNoValue<DiscordThreadChannel>();
         }
     }
 
     /// <summary>
     /// Represents a discord role converter.
     /// </summary>
     public class DiscordRoleConverter : IArgumentConverter<DiscordRole>
     {
         /// <summary>
         /// Gets the role regex.
         /// </summary>
         private static Regex RoleRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordRoleConverter"/> class.
         /// </summary>
         static DiscordRoleConverter()
         {
-#if NETSTANDARD1_3
-            RoleRegex = new Regex(@"^<@&(\d+?)>$", RegexOptions.ECMAScript);
-#else
-            RoleRegex = new Regex(@"^<@&(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            RoleRegex = DiscordRegEx.Role;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordRole>> IArgumentConverter<DiscordRole>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ctx.Guild == null)
                 return Task.FromResult(Optional.FromNoValue<DiscordRole>());
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var rid))
             {
                 var result = ctx.Guild.GetRole(rid);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordRole>();
                 return Task.FromResult(ret);
             }
 
             var m = RoleRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out rid))
             {
                 var result = ctx.Guild.GetRole(rid);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordRole>();
                 return Task.FromResult(ret);
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var rol = ctx.Guild.Roles.Values.FirstOrDefault(xr => (cs ? xr.Name : xr.Name.ToLowerInvariant()) == value);
             return Task.FromResult(rol != null ? Optional.FromValue(rol) : Optional.FromNoValue<DiscordRole>());
         }
     }
 
     /// <summary>
     /// Represents a discord guild converter.
     /// </summary>
     public class DiscordGuildConverter : IArgumentConverter<DiscordGuild>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordGuild>> IArgumentConverter<DiscordGuild>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var gid))
             {
                 return ctx.Client.Guilds.TryGetValue(gid, out var result)
                     ? Task.FromResult(Optional.FromValue(result))
                     : Task.FromResult(Optional.FromNoValue<DiscordGuild>());
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value?.ToLowerInvariant();
 
             var gld = ctx.Client.Guilds.Values.FirstOrDefault(xg => (cs ? xg.Name : xg.Name.ToLowerInvariant()) == value);
             return Task.FromResult(gld != null ? Optional.FromValue(gld) : Optional.FromNoValue<DiscordGuild>());
         }
     }
 
 
     /// <summary>
     /// Represents a discord invite converter.
     /// </summary>
     public class DiscordInviteConverter : IArgumentConverter<DiscordInvite>
     {
         /// <summary>
         /// Gets the invite regex.
         /// </summary>
         private static Regex InviteRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordInviteConverter"/> class.
         /// </summary>
         static DiscordInviteConverter()
         {
-#if NETSTANDARD1_3
-            InviteRegex = new Regex(@"^(https?:\/\/)?(www\.)?(discord\.(gg|io|me|li)|discordapp\.com\/invite)\/(.+[a-z])$", RegexOptions.ECMAScript);
-#else
-            InviteRegex = new Regex(@"^(https?:\/\/)?(www\.)?(discord\.(gg|io|me|li)|discordapp\.com\/invite)\/(.+[a-z])$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            InviteRegex = DiscordRegEx.Invite;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordInvite>> IArgumentConverter<DiscordInvite>.ConvertAsync(string value, CommandContext ctx)
         {
             var m = InviteRegex.Match(value);
             if (m.Success)
             {
                 var result = await ctx.Client.GetInviteByCodeAsync(m.Groups[5].Value).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordInvite>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value?.ToLowerInvariant();
 
             var inv  = await ctx.Client.GetInviteByCodeAsync(value);
             return inv != null ? Optional.FromValue(inv) : Optional.FromNoValue<DiscordInvite>();
         }
     }
 
     /// <summary>
     /// Represents a discord message converter.
     /// </summary>
     public class DiscordMessageConverter : IArgumentConverter<DiscordMessage>
     {
         /// <summary>
         /// Gets the message path regex.
         /// </summary>
         private static Regex MessagePathRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMessageConverter"/> class.
         /// </summary>
         static DiscordMessageConverter()
         {
-#if NETSTANDARD1_3
-            MessagePathRegex = new Regex(@"^\/channels\/(?<guild>(?:\d+|@me))\/(?<channel>\d+)\/(?<message>\d+)\/?$", RegexOptions.ECMAScript);
-#else
-            MessagePathRegex = new Regex(@"^\/channels\/(?<guild>(?:\d+|@me))\/(?<channel>\d+)\/(?<message>\d+)\/?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            MessagePathRegex = DiscordRegEx.MessageLink;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordMessage>> IArgumentConverter<DiscordMessage>.ConvertAsync(string value, CommandContext ctx)
         {
             if (string.IsNullOrWhiteSpace(value))
                 return Optional.FromNoValue<DiscordMessage>();
 
             var msguri = value.StartsWith("<") && value.EndsWith(">") ? value.Substring(1, value.Length - 2) : value;
             ulong mid;
             if (Uri.TryCreate(msguri, UriKind.Absolute, out var uri))
             {
                 if (uri.Host != "discordapp.com" && uri.Host != "discord.com" && !uri.Host.EndsWith(".discordapp.com") && !uri.Host.EndsWith(".discord.com"))
                     return Optional.FromNoValue<DiscordMessage>();
 
                 var uripath = MessagePathRegex.Match(uri.AbsolutePath);
                 if (!uripath.Success
                     || !ulong.TryParse(uripath.Groups["channel"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var cid)
                     || !ulong.TryParse(uripath.Groups["message"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out mid))
                     return Optional.FromNoValue<DiscordMessage>();
 
                 var chn = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
                 if (chn == null)
                     return Optional.FromNoValue<DiscordMessage>();
 
                 var msg = await chn.GetMessageAsync(mid).ConfigureAwait(false);
                 return msg != null ? Optional.FromValue(msg) : Optional.FromNoValue<DiscordMessage>();
             }
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out mid))
             {
                 var result = await ctx.Channel.GetMessageAsync(mid).ConfigureAwait(false);
                 return result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordMessage>();
             }
 
             return Optional.FromNoValue<DiscordMessage>();
         }
     }
 
+    /// <summary>
+    /// Represents a discord scheduled event converter.
+    /// </summary>
+    public class DiscordScheduledEventConverter : IArgumentConverter<DiscordScheduledEvent>
+    {
+        /// <summary>
+        /// Gets the event regex.
+        /// </summary>
+        private static Regex EventRegex { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DiscordScheduledEventConverter"/> class.
+        /// </summary>
+        static DiscordScheduledEventConverter()
+        {
+            EventRegex = DiscordRegEx.Event;
+        }
+
+        /// <summary>
+        /// Converts a string.
+        /// </summary>
+        /// <param name="value">The string to convert.</param>
+        /// <param name="ctx">The command context.</param>
+        async Task<Optional<DiscordScheduledEvent>> IArgumentConverter<DiscordScheduledEvent>.ConvertAsync(string value, CommandContext ctx)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return Optional.FromNoValue<DiscordScheduledEvent>();
+
+            var msguri = value.StartsWith("<") && value.EndsWith(">") ? value.Substring(1, value.Length - 2) : value;
+            ulong seid;
+            if (Uri.TryCreate(msguri, UriKind.Absolute, out var uri))
+            {
+                if (uri.Host != "discordapp.com" && uri.Host != "discord.com" && !uri.Host.EndsWith(".discordapp.com") && !uri.Host.EndsWith(".discord.com"))
+                    return Optional.FromNoValue<DiscordScheduledEvent>();
+
+                var uripath = EventRegex.Match(uri.AbsolutePath);
+                if (!uripath.Success
+                    || !ulong.TryParse(uripath.Groups["guild"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var gid)
+                    || !ulong.TryParse(uripath.Groups["event"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out seid))
+                    return Optional.FromNoValue<DiscordScheduledEvent>();
+
+                var guild = await ctx.Client.GetGuildAsync(gid).ConfigureAwait(false);
+                if (guild == null)
+                    return Optional.FromNoValue<DiscordScheduledEvent>();
+
+                var ev = await guild.GetScheduledEventAsync(seid).ConfigureAwait(false);
+                return ev != null ? Optional.FromValue(ev) : Optional.FromNoValue<DiscordScheduledEvent>();
+            }
+
+            if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out seid))
+            {
+                var result = await ctx.Guild.GetScheduledEventAsync(seid).ConfigureAwait(false);
+                return result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordScheduledEvent>();
+            }
+
+            return Optional.FromNoValue<DiscordScheduledEvent>();
+        }
+    }
+
     /// <summary>
     /// Represents a discord emoji converter.
     /// </summary>
     public class DiscordEmojiConverter : IArgumentConverter<DiscordEmoji>
     {
         /// <summary>
         /// Gets the emote regex.
         /// </summary>
         private static Regex EmoteRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordEmojiConverter"/> class.
         /// </summary>
         static DiscordEmojiConverter()
         {
-#if NETSTANDARD1_3
-            EmoteRegex = new Regex(@"^<a?:([a-zA-Z0-9_]+?):(\d+?)>$", RegexOptions.ECMAScript);
-#else
-            EmoteRegex = new Regex(@"^<(?<animated>a)?:(?<name>[a-zA-Z0-9_]+?):(?<id>\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            EmoteRegex = DiscordRegEx.Emoji;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordEmoji>> IArgumentConverter<DiscordEmoji>.ConvertAsync(string value, CommandContext ctx)
         {
             if (DiscordEmoji.TryFromUnicode(ctx.Client, value, out var emoji))
             {
                 var result = emoji;
                 var ret = Optional.FromValue(result);
                 return Task.FromResult(ret);
             }
 
             var m = EmoteRegex.Match(value);
             if (m.Success)
             {
                 var sid = m.Groups["id"].Value;
                 var name = m.Groups["name"].Value;
                 var anim = m.Groups["animated"].Success;
 
                 return !ulong.TryParse(sid, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id)
                     ? Task.FromResult(Optional.FromNoValue<DiscordEmoji>())
                     : DiscordEmoji.TryFromGuildEmote(ctx.Client, id, out emoji)
                     ? Task.FromResult(Optional.FromValue(emoji))
                     : Task.FromResult(Optional.FromValue(new DiscordEmoji
                     {
                         Discord = ctx.Client,
                         Id = id,
                         Name = name,
                         IsAnimated = anim,
                         RequiresColons = true,
                         IsManaged = false
                     }));
             }
 
             return Task.FromResult(Optional.FromNoValue<DiscordEmoji>());
         }
     }
 
     /// <summary>
     /// Represents a discord color converter.
     /// </summary>
     public class DiscordColorConverter : IArgumentConverter<DiscordColor>
     {
         /// <summary>
         /// Gets the color regex hex.
         /// </summary>
         private static Regex ColorRegexHex { get; }
         /// <summary>
         /// Gets the color regex rgb.
         /// </summary>
         private static Regex ColorRegexRgb { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordColorConverter"/> class.
         /// </summary>
         static DiscordColorConverter()
         {
-#if NETSTANDARD1_3
-            ColorRegexHex = new Regex(@"^#?([a-fA-F0-9]{6})$", RegexOptions.ECMAScript);
-            ColorRegexRgb = new Regex(@"^(\d{1,3})\s*?,\s*?(\d{1,3}),\s*?(\d{1,3})$", RegexOptions.ECMAScript);
-#else
-            ColorRegexHex = new Regex(@"^#?([a-fA-F0-9]{6})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-            ColorRegexRgb = new Regex(@"^(\d{1,3})\s*?,\s*?(\d{1,3}),\s*?(\d{1,3})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            ColorRegexHex = CommonRegEx.HexColorString;
+            ColorRegexRgb = CommonRegEx.RgbColorString;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordColor>> IArgumentConverter<DiscordColor>.ConvertAsync(string value, CommandContext ctx)
         {
             var m = ColorRegexHex.Match(value);
             if (m.Success && int.TryParse(m.Groups[1].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var clr))
                 return Task.FromResult(Optional.FromValue<DiscordColor>(clr));
 
             m = ColorRegexRgb.Match(value);
             if (m.Success)
             {
                 var p1 = byte.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var r);
                 var p2 = byte.TryParse(m.Groups[2].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var g);
                 var p3 = byte.TryParse(m.Groups[3].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var b);
 
                 return !(p1 && p2 && p3)
                     ? Task.FromResult(Optional.FromNoValue<DiscordColor>())
                     : Task.FromResult(Optional.FromValue(new DiscordColor(r, g, b)));
             }
 
             return Task.FromResult(Optional.FromNoValue<DiscordColor>());
         }
     }
 }
diff --git a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
index c4675b2c1..f9832adee 100644
--- a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
@@ -1,148 +1,145 @@
 // 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;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
+using DisCatSharp.Common.RegularExpressions;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
     /// <summary>
     /// Represents a date time converter.
     /// </summary>
     public class DateTimeConverter : IArgumentConverter<DateTime>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DateTime>> IArgumentConverter<DateTime>.ConvertAsync(string value, CommandContext ctx)
         {
             return DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
                 ? Task.FromResult(new Optional<DateTime>(result))
                 : Task.FromResult(Optional.FromNoValue<DateTime>());
         }
     }
 
     /// <summary>
     /// Represents a date time offset converter.
     /// </summary>
     public class DateTimeOffsetConverter : IArgumentConverter<DateTimeOffset>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DateTimeOffset>> IArgumentConverter<DateTimeOffset>.ConvertAsync(string value, CommandContext ctx)
         {
             return DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
                 ? Task.FromResult(Optional.FromValue(result))
                 : Task.FromResult(Optional.FromNoValue<DateTimeOffset>());
         }
     }
 
     /// <summary>
     /// Represents a time span converter.
     /// </summary>
     public class TimeSpanConverter : IArgumentConverter<TimeSpan>
     {
         /// <summary>
         /// Gets or sets the time span regex.
         /// </summary>
         private static Regex TimeSpanRegex { get; set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="TimeSpanConverter"/> class.
         /// </summary>
         static TimeSpanConverter()
         {
-#if NETSTANDARD1_3
-            TimeSpanRegex = new Regex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript);
-#else
-            TimeSpanRegex = new Regex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            TimeSpanRegex = CommonRegEx.TimeSpan;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<TimeSpan>> IArgumentConverter<TimeSpan>.ConvertAsync(string value, CommandContext ctx)
         {
             if (value == "0")
                 return Task.FromResult(Optional.FromValue(TimeSpan.Zero));
 
             if (int.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _))
                 return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
             if (!ctx.Config.CaseSensitive)
                 value = value.ToLowerInvariant();
 
             if (TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out var result))
                 return Task.FromResult(Optional.FromValue(result));
 
             var gps = new string[] { "days", "hours", "minutes", "seconds" };
             var mtc = TimeSpanRegex.Match(value);
             if (!mtc.Success)
                 return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
             var d = 0;
             var h = 0;
             var m = 0;
             var s = 0;
             foreach (var gp in gps)
             {
                 var gpc = mtc.Groups[gp].Value;
                 if (string.IsNullOrWhiteSpace(gpc))
                     continue;
 
                 var gpt = gpc[gpc.Length - 1];
                 int.TryParse(gpc.Substring(0, gpc.Length - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var val);
                 switch (gpt)
                 {
                     case 'd':
                         d = val;
                         break;
 
                     case 'h':
                         h = val;
                         break;
 
                     case 'm':
                         m = val;
                         break;
 
                     case 's':
                         s = val;
                         break;
                 }
             }
             result = new TimeSpan(d, h, m, s);
             return Task.FromResult(Optional.FromValue(result));
         }
     }
 }
diff --git a/DisCatSharp.CommandsNext/DisCatSharp.CommandsNext.csproj b/DisCatSharp.CommandsNext/DisCatSharp.CommandsNext.csproj
index cc520bb74..3fd81da16 100644
--- a/DisCatSharp.CommandsNext/DisCatSharp.CommandsNext.csproj
+++ b/DisCatSharp.CommandsNext/DisCatSharp.CommandsNext.csproj
@@ -1,43 +1,44 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
   <Import Project="../Version.targets" />
   <Import Project="../DisCatSharp.targets" />
   <Import Project="../Package.targets" />
   <Import Project="../NuGet.targets" />
 
   <PropertyGroup>
     <AssemblyName>DisCatSharp.CommandsNext</AssemblyName>
     <RootNamespace>DisCatSharp.CommandsNext</RootNamespace>
     <OutputType>Library</OutputType>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
   </PropertyGroup>
 
   <PropertyGroup>
     <PackageId>DisCatSharp.CommandsNext</PackageId>
     <Description>CommandNext extension for DisCatSharp.</Description>
     <PackageTags>discord, discord-api, bots, discord-bots, chat, dcs, discatsharp, csharp, dotnet, vb-net, fsharp, commands, commandsnext</PackageTags>
     <PackageLicenseExpression />
     <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\DisCatSharp\DisCatSharp.csproj" />
+    <ProjectReference Include="..\DisCatSharp.Common\DisCatSharp.Common.csproj" />
   </ItemGroup>
 
   <ItemGroup>
     <None Include="..\LICENSE.md">
       <Pack>True</Pack>
       <PackagePath></PackagePath>
     </None>
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.DependencyValidation.Analyzers" Version="0.11.0" />
   </ItemGroup>
 
 </Project>
diff --git a/DisCatSharp.Common/RegularExpressions/CommonRegEx.cs b/DisCatSharp.Common/RegularExpressions/CommonRegEx.cs
new file mode 100644
index 000000000..95744fcaf
--- /dev/null
+++ b/DisCatSharp.Common/RegularExpressions/CommonRegEx.cs
@@ -0,0 +1,53 @@
+// This file is part of the DisCatSharp project, a fork of DSharpPlus.
+//
+// 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.Text;
+using System.Text.RegularExpressions;
+
+namespace DisCatSharp.Common.RegularExpressions
+{
+    /// <summary>
+    /// Provides common regex.
+    /// </summary>
+    public static class CommonRegEx
+    {
+        /// <summary>
+        /// Represents a hex color string.
+        /// </summary>
+        public static Regex HexColorString
+            => new(@"^#?([a-fA-F0-9]{6})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a rgp color string.
+        /// </summary>
+        public static Regex RgbColorString
+            => new(@"^(\d{1,3})\s*?,\s*?(\d{1,3}),\s*?(\d{1,3})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a timespan.
+        /// </summary>
+        public static Regex TimeSpan
+            => new(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+    }
+}
diff --git a/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs b/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
new file mode 100644
index 000000000..8350a3964
--- /dev/null
+++ b/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
@@ -0,0 +1,125 @@
+// This file is part of the DisCatSharp project, a fork of DSharpPlus.
+//
+// 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.Text;
+using System.Text.RegularExpressions;
+
+namespace DisCatSharp.Common.RegularExpressions
+{
+    /// <summary>
+    /// Provides common regex for discord related things.
+    /// </summary>
+    public static class DiscordRegEx
+    {
+        /// <summary>
+        /// Represents a invite.
+        /// </summary>
+        public static Regex Invite
+            => new(@"^(https?:\/\/)?(www\.)?(discord\.(gg|io|me|li)|discordapp\.(com|net)\/invite)\/(.+[a-z])$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a message link.
+        /// </summary>
+        public static Regex MessageLink
+            => new(@"^\/channels\/(?<guild>(?:\d+|@me))\/(?<channel>\d+)\/(?<message>\d+)\/?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a emoji.
+        /// </summary>
+        public static Regex Emoji
+            => new(@"^<(?<animated>a)?:(?<name>[a-zA-Z0-9_]+?):(?<id>\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a animated emoji.
+        /// </summary>
+        public static Regex AnimatedEmoji
+            => new(@"^<(?<animated>a):(?<name>\w{2,32}):(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a non-animated emoji.
+        /// </summary>
+        public static Regex StaticEmoji
+            => new(@"^<:(?<name>\w{2,32}):(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a timestamp.
+        /// </summary>
+        public static Regex Timestamp
+            => new(@"^<t:(?<timestamp>-?\d{1,13})(:(?<style>[tTdDfFR]))?>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a default styled timestamp.
+        /// </summary>
+        public static Regex DefaultStyledTimestamp
+            => new(@"^<t:(?<timestamp>-?\d{1,13})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a styled timestamp.
+        /// </summary>
+        public static Regex StyledTimestamp
+            => new(@"^<t:(?<timestamp>-?\d{1,13}):(?<style>[tTdDfFR])>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a role.
+        /// </summary>
+        public static Regex Role
+            => new(@"^<@&(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a channel.
+        /// </summary>
+        public static Regex Channel
+            => new(@"^<#(\d+)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a user.
+        /// </summary>
+        public static Regex User
+            => new(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a user with nickname.
+        /// </summary>
+        public static Regex UserWithNickname
+            => new(@"^<@\!(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a user with optional nickname.
+        /// </summary>
+        public static Regex UserWithOptionalNickname
+            => new(@"^<@\!?(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a user without nickname.
+        /// </summary>
+        public static Regex UserWithoutNickname
+            => new(@"^<@(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a event.
+        /// </summary>
+        public static Regex Event
+            => new(@"^\/events\/(?<guild>\d+)\/(?<event>\d+)$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+    }
+}
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.cs b/DisCatSharp/Entities/Guild/DiscordGuild.cs
index 7f190b417..790916d09 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,3490 +1,3542 @@
 // 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 this guild's hub type, if applicable.
         /// </summary>
         [JsonProperty("hub_type", NullValueHandling = NullValueHandling.Ignore)]
         public HubType HubType { get; internal set; }
 
         /// <summary>
         /// Gets a dictionary of all by position ordered channels associated with this guild. The dictionary's key is the channel ID.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordChannel> OrderedChannels => new ReadOnlyDictionary<ulong, DiscordChannel>(this.InternalSortChannels());
 
         /// <summary>
         /// Sorts the channels.
         /// </summary>
         private Dictionary<ulong, DiscordChannel> InternalSortChannels()
         {
             Dictionary<ulong, DiscordChannel> keyValuePairs = new();
             var ochannels = this.GetOrderedChannels();
             foreach (var ochan in ochannels)
             {
                 if (ochan.Key != 0)
                     keyValuePairs.Add(ochan.Key, this.GetChannel(ochan.Key));
                 foreach (var chan in ochan.Value)
                     keyValuePairs.Add(chan.Id, chan);
             }
             return keyValuePairs;
         }
 
         /// <summary>
         /// Gets an ordered <see cref="DiscordChannel"/> list out of the channel cache.
         /// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
         /// Ignore the 0 key here, because that indicates that this is the "has no category" list.
         /// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
         /// </summary>
         /// <returns>A ordered list of categories with its channels</returns>
         public Dictionary<ulong, List<DiscordChannel>> GetOrderedChannels()
         {
             IReadOnlyList<DiscordChannel> 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite" /> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client is not the owner of the guild.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAsync()
             => this.Discord.ApiClient.DeleteGuildAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild.
         /// </summary>
         /// <param name="action">Action to perform on this guild..</param>
         /// <returns>The modified guild object.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> ModifyAsync(Action<GuildEditModel> action)
         {
             var mdl = new GuildEditModel();
             action(mdl);
 
             var afkChannelId = 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> ModifyCommunitySettingsAsync(bool enabled, DiscordChannel rulesChannel = null, DiscordChannel publicUpdatesChannel = null, string preferredLocale = "en-US", string description = null, DefaultMessageNotifications defaultMessageNotifications = DefaultMessageNotifications.MentionsOnly, string reason = null)
         {
             var verificationLevel = this.VerificationLevel;
             if(this.VerificationLevel != VerificationLevel.Highest)
             {
                 verificationLevel = VerificationLevel.High;
             }
 
             var explicitContentFilter = ExplicitContentFilter.AllMembers;
 
             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>
+        /// Timeout a specified member in this guild.
+        /// </summary>
+        /// <param name="member_id">Member to timeout.</param>
+        /// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
+        /// <param name="reason">Reason for audit logs.</param>
+        /// <returns></returns>
+        /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        public Task TimeoutAsync(ulong member_id, DateTimeOffset until, string reason = null)
+            => until.Subtract(DateTimeOffset.UtcNow).Days > 28 ? throw new ArgumentException("Timeout can not be longer than 28 days") : this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, member_id, until, reason);
+
+        /// <summary>
+        /// Timeout a specified member in this guild.
+        /// </summary>
+        /// <param name="member_id">Member to timeout.</param>
+        /// <param name="until">The timespan to time out the user. Up to 28 days.</param>
+        /// <param name="reason">Reason for audit logs.</param>
+        /// <returns></returns>
+        /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        public Task TimeoutAsync(ulong member_id, TimeSpan until, string reason = null)
+            => this.TimeoutAsync(member_id, DateTimeOffset.UtcNow + until, reason);
+
+        /// <summary>
+        /// Timeout a specified member in this guild.
+        /// </summary>
+        /// <param name="member_id">Member to timeout.</param>
+        /// <param name="until">The datetime to time out the user. Up to 28 days.</param>
+        /// <param name="reason">Reason for audit logs.</param>
+        /// <returns></returns>
+        /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        public Task TimeoutAsync(ulong member_id, DateTime until, string reason = null)
+            => this.TimeoutAsync(member_id, until.ToUniversalTime() - DateTime.UtcNow, reason);
+
+        /// <summary>
+        /// Removes the timeout from a specified member in this guild.
+        /// </summary>
+        /// <param name="member_id">Member to remove the timeout from.</param>
+        /// <param name="reason">Reason for audit logs.</param>
+        /// <returns></returns>
+        /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
+        /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+        public Task RemoveTimeoutAsync(ulong member_id, string reason = null) => this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, member_id, null, reason);
+
         /// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanMemberAsync(DiscordMember member, int 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanMemberAsync(ulong 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanMemberAsync(DiscordUser user, string reason = null)
             => this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user.Id, reason);
 
         /// <summary>
         /// Unbans a user by ID.
         /// </summary>
         /// <param name="user_id">ID of the user to unban.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanMemberAsync(ulong user_id, string reason = null)
             => this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user_id, reason);
 
         /// <summary>
         /// Leaves this guild.
         /// </summary>
         /// <returns></returns>
         /// <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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordBan>> GetBansAsync()
             => 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="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="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="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="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="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="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> GetScheduledEventAsync(DiscordScheduledEvent scheduledEvent, bool? withUserCount = null)
             => await this.GetScheduledEventAsync(scheduledEvent.Id, withUserCount);
 
         /// <summary>
         /// Gets the guilds scheduled events.
         /// </summary>
         /// <param name="withUserCount">Whether to include user count.</param>
         /// <returns>A list of the guilds scheduled events.</returns>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> GetScheduledEventsAsync(bool? withUserCount = null)
             => await this.Discord.ApiClient.ListGuildScheduledEventsAsync(this.Id, withUserCount);
         #endregion
 
         /// <summary>
         /// Creates a new text channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new channel.</param>
         /// <param name="parent">Category to put this channel in.</param>
         /// <param name="topic">Topic of the channel.</param>
         /// <param name="overwrites">Permission overwrites for this channel.</param>
         /// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <param name="perUserRateLimit">Slow mode timeout for users.</param>
         /// <returns>The newly-created channel.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateTextChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateChannelCategoryAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Category, null, Optional.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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
         public Task<DiscordChannel> CreateStageChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.Stage, null, Optional.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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
         public Task<DiscordChannel> CreateNewsChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateVoiceChannelAsync(string name, DiscordChannel parent = null, int? bitrate = null, int? 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, 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="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<int> GetPruneCountAsync(int days = 7, IEnumerable<DiscordRole> includedRoles = null)
         {
             if (includedRoles != null)
             {
                 includedRoles = includedRoles.Where(r => r != null);
                 var 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<int?> PruneAsync(int days = 7, bool computePruneCount = true, IEnumerable<DiscordRole> includedRoles = null, string reason = null)
         {
             if (includedRoles != null)
             {
                 includedRoles = includedRoles.Where(r => r != null);
                 var 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordIntegration>> GetIntegrationsAsync()
             => this.Discord.ApiClient.GetGuildIntegrationsAsync(this.Id);
 
         /// <summary>
         /// Attaches an integration from current user to this guild.
         /// </summary>
         /// <param name="integration">Integration to attach.</param>
         /// <returns>The integration after being attached to the guild.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordIntegration> AttachUserIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.CreateGuildIntegrationAsync(this.Id, integration.Type, integration.Id);
 
         /// <summary>
         /// Modifies an integration in this guild.
         /// </summary>
         /// <param name="integration">Integration to modify.</param>
         /// <param name="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordIntegration> ModifyIntegrationAsync(DiscordIntegration integration, int 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.DeleteGuildIntegrationAsync(this.Id, integration);
 
         /// <summary>
         /// Forces re-synchronization of an integration for this guild.
         /// </summary>
         /// <param name="integration">Integration to synchronize.</param>
         /// <returns></returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task SyncIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.SyncGuildIntegrationAsync(this.Id, integration.Id);
 
         /// <summary>
         /// Gets the voice regions for this guild.
         /// </summary>
         /// <returns>Voice regions available for this guild.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
         {
             var vrs = await this.Discord.ApiClient.GetGuildVoiceRegionsAsync(this.Id).ConfigureAwait(false);
             foreach (var xvr in vrs)
                 this.Discord.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 
             return vrs;
         }
 
         /// <summary>
         /// Gets an invite from this guild from an invite code.
         /// </summary>
         /// <param name="code">The invite code</param>
         /// <returns>An invite, or null if not in cache.</returns>
         public DiscordInvite GetInvite(string code)
             => this._invites.TryGetValue(code, out var invite) ? invite : null;
 
         /// <summary>
         /// Gets all the invites created for all the channels in this guild.
         /// </summary>
         /// <returns>A collection of invites.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
         {
             var res = await this.Discord.ApiClient.GetGuildInvitesAsync(this.Id).ConfigureAwait(false);
 
             var intents = this.Discord.Configuration.Intents;
 
             if (!intents.HasIntent(DiscordIntents.GuildInvites))
             {
                 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordInvite> GetVanityInviteAsync()
             => this.Discord.ApiClient.GetGuildVanityUrlAsync(this.Id);
 
         /// <summary>
         /// Gets all the webhooks created for all the channels in this guild.
         /// </summary>
         /// <returns>A collection of webhooks this guild has.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
             => this.Discord.ApiClient.GetGuildWebhooksAsync(this.Id);
 
         /// <summary>
         /// Gets this guild's widget image.
         /// </summary>
         /// <param name="bannerType">The format of the widget.</param>
         /// <returns>The URL of the widget image.</returns>
         public string GetWidgetImage(WidgetType bannerType = WidgetType.Shield)
         {
             var param = bannerType switch
             {
                 WidgetType.Banner1 => "banner1",
                 WidgetType.Banner2 => "banner2",
                 WidgetType.Banner3 => "banner3",
                 WidgetType.Banner4 => "banner4",
                 _ => "shield",
             };
             return $"{Endpoints.BASE_URI}{Endpoints.GUILDS}/{this.Id}{Endpoints.WIDGET_PNG}?style={param}";
         }
 
         /// <summary>
         /// Gets a member of this guild by their user ID.
         /// </summary>
         /// <param name="userId">ID of the member to get.</param>
         /// <returns>The requested member.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMember> GetMemberAsync(ulong userId)
         {
             if (this._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="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="DisCatSharp.EventArgs.GuildMembersChunkEventArgs.Presences"/> associated with the fetched members.</param>
         /// <param name="userIds">Whether to limit the request to the specified user ids. Either this or <paramref name="query"/> must not be null.</param>
         /// <param name="nonce">The unique string to identify the response.</param>
         public async Task RequestMembersAsync(string query = "", int limit = 0, bool? presences = null, IEnumerable<ulong> userIds = null, string nonce = null)
         {
             if (this.Discord is not DiscordClient client)
                 throw new InvalidOperationException("This operation is only valid for regular Discord clients.");
 
             if (query == null && userIds == null)
                 throw new ArgumentException("The query and user IDs cannot both be null.");
 
             if (query != null && userIds != null)
                 query = null;
 
             var grgm = new GatewayRequestGuildMembers(this)
             {
                 Query = query,
                 Limit = limit >= 0 ? limit : 0,
                 Presences = presences,
                 UserIds = userIds,
                 Nonce = nonce
             };
 
             var payload = new GatewayPayload
             {
                 OpCode = GatewayOpCode.RequestGuildMembers,
                 Data = grgm
             };
 
             var payloadStr = JsonConvert.SerializeObject(payload, Formatting.None);
             await client.WsSendAsync(payloadStr).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets all the channels this guild has.
         /// </summary>
         /// <returns>A collection of this guild's channels.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordChannel>> GetChannelsAsync()
             => this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
         /// <summary>
         /// Creates a new role in this guild.
         /// </summary>
         /// <param name="name">Name of the role.</param>
         /// <param name="permissions">Permissions for the role.</param>
         /// <param name="color">Color for the role.</param>
         /// <param name="hoist">Whether the role is to be hoisted.</param>
         /// <param name="mentionable">Whether the role is to be mentionable.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created role.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordRole> CreateRoleAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
             => this.Discord.ApiClient.CreateGuildRoleAsync(this.Id, name, permissions, color?.Value, hoist, mentionable, reason);
 
         /// <summary>
         /// Gets a role from this guild by its ID.
         /// </summary>
         /// <param name="id">ID of the role to get.</param>
         /// <returns>Requested role.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordRole GetRole(ulong id)
             => this._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="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="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember 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 "communication_disabled_until":
                                     entrymbu.CommunicationDisabledUntilChange = new PropertyChange<DateTime?>
                                     {
                                         Before = (DateTime?)xc.OldValue,
                                         After = (DateTime?)xc.NewValue
                                     };
                                     break;
 
                                 case "$add":
                                     entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
                                     break;
 
                                 case "$remove":
                                     entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.RoleCreate:
                     case AuditLogActionType.RoleDelete:
                     case AuditLogActionType.RoleUpdate:
                         entry = new DiscordAuditLogRoleUpdateEntry
                         {
                             Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entryrol.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "color":
                                     p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
                                     p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
                                     entryrol.ColorChange = new PropertyChange<int?>
                                     {
                                         Before = p1 ? (int?)t3 : null,
                                         After = p2 ? (int?)t4 : null
                                     };
                                     break;
 
                                 case "permissions":
                                     entryrol.PermissionChange = new PropertyChange<Permissions?>
                                     {
                                         Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
                                         After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
                                     };
                                     break;
 
                                 case "position":
                                     entryrol.PositionChange = new PropertyChange<int?>
                                     {
                                         Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
                                         After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
                                     };
                                     break;
 
                                 case "mentionable":
                                     entryrol.MentionableChange = new PropertyChange<bool?>
                                     {
                                         Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
                                         After = xc.NewValue != null ? (bool?)xc.NewValue : null
                                     };
                                     break;
 
                                 case "hoist":
                                     entryrol.HoistChange = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue
                                     };
                                     break;
 
                                 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="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordGuildEmoji>> GetEmojisAsync()
             => this.Discord.ApiClient.GetGuildEmojisAsync(this.Id);
 
         /// <summary>
         /// Gets this guild's specified custom emoji.
         /// </summary>
         /// <param name="id">ID of the emoji to get.</param>
         /// <returns>The requested custom emoji.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> GetEmojiAsync(ulong id)
             => this.Discord.ApiClient.GetGuildEmojiAsync(this.Id, id);
 
         /// <summary>
         /// Creates a new custom emoji for this guild.
         /// </summary>
         /// <param name="name">Name of the new emoji.</param>
         /// <param name="image">Image to use as the emoji.</param>
         /// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns>The newly-created emoji.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> CreateEmojiAsync(string name, Stream image, IEnumerable<DiscordRole> roles = null, string reason = null)
         {
             if (string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
 
             name = name.Trim();
             if (name.Length < 2 || name.Length > 50)
                 throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.");
 
             if (image == null)
                 throw new ArgumentNullException(nameof(image));
 
             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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> ModifyEmojiAsync(DiscordGuildEmoji emoji, string name, IEnumerable<DiscordRole> roles = null, string reason = null)
         {
             if (emoji == null)
                 throw new ArgumentNullException(nameof(emoji));
 
             if (emoji.Guild.Id != this.Id)
                 throw new ArgumentException("This emoji does not belong to this guild.");
 
             if (string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
 
             name = name.Trim();
             return name.Length < 2 || name.Length > 50
                 ? throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.")
                 : this.Discord.ApiClient.ModifyGuildEmojiAsync(this.Id, emoji.Id, name, roles?.Select(xr => xr.Id), reason);
         }
 
         /// <summary>
         /// Deletes this guild's custom emoji.
         /// </summary>
         /// <param name="emoji">Emoji to delete.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns></returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task 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="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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
         public Task<DiscordSticker> GetStickerAsync(ulong 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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordSticker> CreateStickerAsync(string name, string description, DiscordEmoji emoji, Stream file, StickerFormat format, string reason = null)
         {
             var fileExt = format switch
             {
                 StickerFormat.PNG => "png",
                 StickerFormat.APNG => "png",
                 StickerFormat.LOTTIE => "json",
                 _ => throw new InvalidOperationException("This format is not supported.")
             };
 
             var contentType = format switch
             {
                 StickerFormat.PNG => "image/png",
                 StickerFormat.APNG => "image/png",
                 StickerFormat.LOTTIE => "application/json",
                 _ => throw new InvalidOperationException("This format is not supported.")
             };
 
             return emoji.Id is not 0
                 ? throw new InvalidOperationException("Only unicode emoji can be used for stickers.")
                 : name.Length < 2 || name.Length > 30
                 ? throw new ArgumentOutOfRangeException(nameof(name), "Sticker name needs to be between 2 and 30 characters long.")
                 : description.Length < 1 || description.Length > 100
                 ? throw new ArgumentOutOfRangeException(nameof(description), "Sticker description needs to be between 1 and 100 characters long.")
                 : this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new("sticker", file, null, fileExt, contentType), reason);
         }
 
         /// <summary>
         /// Modifies a sticker
         /// </summary>
         /// <param name="sticker">The id of the sticker to modify</param>
         /// <param name="name">The name of the sticker</param>
         /// <param name="description">The description of the sticker</param>
         /// <param name="emoji">The emoji to associate with this sticker.</param>
         /// <param name="reason">Audit log reason</param>
         /// <returns>A sticker object</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
         public async Task<DiscordSticker> ModifyStickerAsync(ulong sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
         {
 
             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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
         public Task<DiscordSticker> ModifyStickerAsync(DiscordSticker sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
             => this.ModifyStickerAsync(sticker.Id, name, description, emoji, reason);
 
         /// <summary>
         /// Deletes a sticker
         /// </summary>
         /// <param name="sticker">Id of sticker to delete</param>
         /// <param name="reason">Audit log reason</param>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
         public Task DeleteStickerAsync(ulong sticker, string reason = null)
         {
             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="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
         public Task DeleteStickerAsync(DiscordSticker sticker, string reason = null)
             => this.DeleteStickerAsync(sticker.Id, reason);
 
         /// <summary>
         /// <para>Gets the default channel for this guild.</para>
         /// <para>Default channel is the first channel current member can see.</para>
         /// </summary>
         /// <returns>This member's default guild.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordChannel GetDefaultChannel()
         {
             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="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordGuildTemplate>> GetTemplatesAsync()
             => this.Discord.ApiClient.GetGuildTemplatesAsync(this.Id);
 
         /// <summary>
         /// Creates a guild template.
         /// </summary>
         /// <param name="name">Name of the template.</param>
         /// <param name="description">Description of the template.</param>
         /// <returns>The template created.</returns>
         /// <exception cref="DisCatSharp.Exceptions.BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> CreateTemplateAsync(string name, string description = null)
             => this.Discord.ApiClient.CreateGuildTemplateAsync(this.Id, name, description);
 
         /// <summary>
         /// Syncs the template to the current guild's state.
         /// </summary>
         /// <param name="code">The code of the template to sync.</param>
         /// <returns>The template synced.</returns>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> SyncTemplateAsync(string code)
             => this.Discord.ApiClient.SyncGuildTemplateAsync(this.Id, code);
 
         /// <summary>
         /// Modifies the template's metadata.
         /// </summary>
         /// <param name="code">The template's code.</param>
         /// <param name="name">Name of the template.</param>
         /// <param name="description">Description of the template.</param>
         /// <returns>The template modified.</returns>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> ModifyTemplateAsync(string code, string name = null, string description = null)
             => this.Discord.ApiClient.ModifyGuildTemplateAsync(this.Id, code, name, description);
 
         /// <summary>
         /// Deletes the template.
         /// </summary>
         /// <param name="code">The code of the template to delete.</param>
         /// <returns>The deleted template.</returns>
         /// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> DeleteTemplateAsync(string code)
             => this.Discord.ApiClient.DeleteGuildTemplateAsync(this.Id, code);
 
         /// <summary>
         /// Gets this guild's membership screening form.
         /// </summary>
         /// <returns>This guild's membership screening form.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildMembershipScreening> GetMembershipScreeningFormAsync()
             => this.Discord.ApiClient.GetGuildMembershipScreeningFormAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild's membership screening form.
         /// </summary>
         /// <param name="action">Action to perform</param>
         /// <returns>The modified screening form.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuildMembershipScreening> ModifyMembershipScreeningFormAsync(Action<MembershipScreeningEditModel> action)
         {
             var mdl = new MembershipScreeningEditModel();
             action(mdl);
             return await this.Discord.ApiClient.ModifyGuildMembershipScreeningFormAsync(this.Id, mdl.Enabled, mdl.Fields, mdl.Description);
         }
 
         /// <summary>
         /// Gets all the application commands in this guild.
         /// </summary>
         /// <returns>A list of application commands in this guild.</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> GetApplicationCommandsAsync() =>
             this.Discord.ApiClient.GetGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id);
 
         /// <summary>
         /// Overwrites the existing application commands in this guild. New commands are automatically created and missing commands are automatically delete
         /// </summary>
         /// <param name="commands">The list of commands to overwrite with.</param>
         /// <returns>The list of guild commands</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
             this.Discord.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id, commands);
 
         /// <summary>
         /// Creates or overwrites a application command in this guild.
         /// </summary>
         /// <param name="command">The command to create.</param>
         /// <returns>The created command.</returns>
         public Task<DiscordApplicationCommand> CreateApplicationCommandAsync(DiscordApplicationCommand command) =>
             this.Discord.ApiClient.CreateGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, command);
 
         /// <summary>
         /// Edits a application command in this guild.
         /// </summary>
         /// <param name="commandId">The id of the command to edit.</param>
         /// <param name="action">Action to perform.</param>
         /// <returns>The edit command.</returns>
         public async Task<DiscordApplicationCommand> EditApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
         {
             var mdl = new ApplicationCommandEditModel();
             action(mdl);
             return await this.Discord.ApiClient.EditGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets this guild's welcome screen.
         /// </summary>
         /// <returns>This guild's welcome screen object.</returns>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildWelcomeScreen> GetWelcomeScreenAsync() =>
             this.Discord.ApiClient.GetGuildWelcomeScreenAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild's welcome screen.
         /// </summary>
         /// <param name="action">Action to perform.</param>
         /// <returns>The modified welcome screen.</returns>
         /// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
         /// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuildWelcomeScreen> ModifyWelcomeScreenAsync(Action<WelcomeScreenEditModel> action)
         {
             var mdl = new WelcomeScreenEditModel();
             action(mdl);
             return await this.Discord.ApiClient.ModifyGuildWelcomeScreenAsync(this.Id, mdl.Enabled, mdl.WelcomeChannels, mdl.Description).ConfigureAwait(false);
         }
         #endregion
 
         /// <summary>
         /// Returns a string representation of this guild.
         /// </summary>
         /// <returns>String representation of this guild.</returns>
         public override string ToString() => $"Guild {this.Id}; {this.Name}";
 
         /// <summary>
         /// Checks whether this <see cref="DiscordGuild"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordGuild"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordGuild);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordGuild"/> is equal to another <see cref="DiscordGuild"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordGuild"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordGuild"/> is equal to this <see cref="DiscordGuild"/>.</returns>
         public bool Equals(DiscordGuild e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordGuild"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordGuild"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordGuild"/> objects are equal.
         /// </summary>
         /// <param name="e1">First guild to compare.</param>
         /// <param name="e2">Second guild to compare.</param>
         /// <returns>Whether the two guilds are equal.</returns>
         public static bool operator ==(DiscordGuild e1, DiscordGuild e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordGuild"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First guild to compare.</param>
         /// <param name="e2">Second guild to compare.</param>
         /// <returns>Whether the two guilds are not equal.</returns>
         public static bool operator !=(DiscordGuild e1, DiscordGuild e2)
             => !(e1 == e2);
 
     }
 
     /// <summary>
     /// Represents guild verification level.
     /// </summary>
     public enum VerificationLevel : int
     {
         /// <summary>
         /// No verification. Anyone can join and chat right away.
         /// </summary>
         None = 0,
 
         /// <summary>
         /// Low verification level. Users are required to have a verified email attached to their account in order to be able to chat.
         /// </summary>
         Low = 1,
 
         /// <summary>
         /// Medium verification level. Users are required to have a verified email attached to their account, and account age need to be at least 5 minutes in order to be able to chat.
         /// </summary>
         Medium = 2,
 
         /// <summary>
         /// High verification level. Users are required to have a verified email attached to their account, account age need to be at least 5 minutes, and they need to be in the server for at least 10 minutes in order to be able to chat.
         /// </summary>
         High = 3,
 
         /// <summary>
         /// Highest verification level. Users are required to have a verified phone number attached to their account.
         /// </summary>
         Highest = 4
     }
 
     /// <summary>
     /// Represents default notification level for a guild.
     /// </summary>
     public enum DefaultMessageNotifications : int
     {
         /// <summary>
         /// All messages will trigger push notifications.
         /// </summary>
         AllMessages = 0,
 
         /// <summary>
         /// Only messages that mention the user (or a role he's in) will trigger push notifications.
         /// </summary>
         MentionsOnly = 1
     }
 
     /// <summary>
     /// Represents multi-factor authentication level required by a guild to use administrator functionality.
     /// </summary>
     public enum MfaLevel : int
     {
         /// <summary>
         /// Multi-factor authentication is not required to use administrator functionality.
         /// </summary>
         Disabled = 0,
 
         /// <summary>
         /// Multi-factor authentication is required to use administrator functionality.
         /// </summary>
         Enabled = 1
     }
 
     /// <summary>
     /// Represents the value of explicit content filter in a guild.
     /// </summary>
     public enum ExplicitContentFilter : int
     {
         /// <summary>
         /// Explicit content filter is disabled.
         /// </summary>
         Disabled = 0,
 
         /// <summary>
         /// Only messages from members without any roles are scanned.
         /// </summary>
         MembersWithoutRoles = 1,
 
         /// <summary>
         /// Messages from all members are scanned.
         /// </summary>
         AllMembers = 2
     }
 
     /// <summary>
     /// Represents the formats for a guild widget.
     /// </summary>
     public enum WidgetType : int
     {
         /// <summary>
         /// The widget is represented in shield format.
         /// <para>This is the default widget type.</para>
         /// </summary>
         Shield = 0,
 
         /// <summary>
         /// The widget is represented as the first banner type.
         /// </summary>
         Banner1 = 1,
 
         /// <summary>
         /// The widget is represented as the second banner type.
         /// </summary>
         Banner2 = 2,
 
         /// <summary>
         /// The widget is represented as the third banner type.
         /// </summary>
         Banner3 = 3,
 
         /// <summary>
         /// The widget is represented in the fourth banner type.
         /// </summary>
         Banner4 = 4
     }
 
     /// <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/Guild/DiscordMember.cs b/DisCatSharp/Entities/Guild/DiscordMember.cs
index 1c567ee13..564a5bdb0 100644
--- a/DisCatSharp/Entities/Guild/DiscordMember.cs
+++ b/DisCatSharp/Entities/Guild/DiscordMember.cs
@@ -1,781 +1,781 @@
 // 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.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a Discord guild member.
     /// </summary>
     public class DiscordMember : DiscordUser, IEquatable<DiscordMember>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMember"/> class.
         /// </summary>
         internal DiscordMember()
         {
             this._role_ids_lazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this._role_ids));
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMember"/> class.
         /// </summary>
         /// <param name="user">The user.</param>
         internal DiscordMember(DiscordUser user)
         {
             this.Discord = user.Discord;
 
             this.Id = user.Id;
 
             this._role_ids = new List<ulong>();
             this._role_ids_lazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this._role_ids));
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMember"/> class.
         /// </summary>
         /// <param name="mbr">The mbr.</param>
         internal DiscordMember(TransportMember mbr)
         {
             this.Id = mbr.User.Id;
             this.IsDeafened = mbr.IsDeafened;
             this.IsMuted = mbr.IsMuted;
             this.JoinedAt = mbr.JoinedAt;
             this.Nickname = mbr.Nickname;
             this.PremiumSince = mbr.PremiumSince;
             this.IsPending = mbr.IsPending;
             this.GuildAvatarHash = mbr.GuildAvatarHash;
             this.GuildBannerHash = mbr.GuildBannerHash;
             this.GuildBio = mbr.GuildBio;
             this.CommunicationDisabledUntil = mbr.CommunicationDisabledUntil;
             this._avatarHash = mbr.AvatarHash;
             this._role_ids = mbr.Roles ?? new List<ulong>();
             this._role_ids_lazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this._role_ids));
         }
 
         /// <summary>
         /// Gets the members avatar hash.
         /// </summary>
         [JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
         public virtual string GuildAvatarHash { get; internal set; }
 
         /// <summary>
         /// Gets the members avatar URL.
         /// </summary>
         [JsonIgnore]
         public string GuildAvatarUrl
             => string.IsNullOrWhiteSpace(this.GuildAvatarHash) ? this.User.AvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this._guild_id.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.AVATARS}/{this.GuildAvatarHash}.{(this.GuildAvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
         /// <summary>
         /// Gets this member's banner url.
         /// </summary>
         [JsonIgnore]
 #pragma warning disable CS0108 // Member hides inherited member; missing new keyword
         public string BannerUrl => this.User.BannerUrl;
 #pragma warning restore CS0108 // Member hides inherited member; missing new keyword
 
         /// <summary>
         /// Gets the member's banner hash.
         /// </summary>
         [JsonIgnore]
         public override string BannerHash
         {
             get => this.User.BannerHash;
             internal set => this.User.BannerHash = value;
         }
 
         /// <summary>
         /// Gets the members banner hash.
         /// </summary>
         [JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
         public virtual string GuildBannerHash { get; internal set; }
 
         /// <summary>
         /// Gets the members banner URL.
         /// </summary>
         [JsonIgnore]
         public string GuildBannerUrl
             => string.IsNullOrWhiteSpace(this.GuildBannerHash) ? this.User.BannerUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this._guild_id.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.GuildBannerHash}.{(this.GuildBannerHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
         /// <summary>
         /// The color of this member's banner. Mutually exclusive with <see cref="BannerHash"/>.
         /// </summary>
         [JsonIgnore]
         public override DiscordColor? BannerColor => this.User.BannerColor;
 
         /// <summary>
         /// Gets this member's nickname.
         /// </summary>
         [JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
         public string Nickname { get; internal set; }
 
         /// <summary>
         /// Gets the members guild bio.
         /// This is not available to bots tho.
         /// </summary>
         [JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
         public string GuildBio { get; internal set; }
 
         [JsonIgnore]
         internal string _avatarHash;
 
         /// <summary>
         /// Gets this member's display name.
         /// </summary>
         [JsonIgnore]
         public string DisplayName
             => this.Nickname ?? this.Username;
 
         /// <summary>
         /// List of role ids
         /// </summary>
         [JsonIgnore]
         internal IReadOnlyList<ulong> RoleIds
             => this._role_ids_lazy.Value;
 
         [JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
         internal List<ulong> _role_ids;
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<ulong>> _role_ids_lazy;
 
         /// <summary>
         /// Gets the list of roles associated with this member.
         /// </summary>
         [JsonIgnore]
         public IEnumerable<DiscordRole> Roles
             => this.RoleIds.Select(id => this.Guild.GetRole(id)).Where(x => x != null);
 
         /// <summary>
         /// Gets the color associated with this user's top color-giving role, otherwise 0 (no color).
         /// </summary>
         [JsonIgnore]
         public DiscordColor Color
         {
             get
             {
                 var role = this.Roles.OrderByDescending(xr => xr.Position).FirstOrDefault(xr => xr.Color.Value != 0);
                 return role != null ? role.Color : new DiscordColor();
             }
         }
 
         /// <summary>
         /// Date the user joined the guild
         /// </summary>
         [JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
         public DateTimeOffset JoinedAt { get; internal set; }
 
         /// <summary>
         /// Date the user started boosting this server
         /// </summary>
         [JsonProperty("premium_since", NullValueHandling = NullValueHandling.Ignore)]
         public DateTimeOffset? PremiumSince { get; internal set; }
 
         /// <summary>
         /// Date until the can communicate again.
         /// </summary>
         [JsonProperty("communication_disabled_until", NullValueHandling = NullValueHandling.Include)]
         public DateTimeOffset? CommunicationDisabledUntil { get; internal set; }
 
         /// <summary>
         /// If the user is deafened
         /// </summary>
         [JsonProperty("is_deafened", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsDeafened { get; internal set; }
 
         /// <summary>
         /// If the user is muted
         /// </summary>
         [JsonProperty("is_muted", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsMuted { get; internal set; }
 
         /// <summary>
         /// Whether the user has not passed the guild's Membership Screening requirements yet.
         /// </summary>
         [JsonProperty("pending", NullValueHandling = NullValueHandling.Ignore)]
         public bool? IsPending { get; internal set; }
 
         /// <summary>
         /// Gets this member's voice state.
         /// </summary>
         [JsonIgnore]
         public DiscordVoiceState VoiceState
             => this.Discord.Guilds[this._guild_id].VoiceStates.TryGetValue(this.Id, out var voiceState) ? voiceState : null;
 
         [JsonIgnore]
         internal ulong _guild_id = 0;
 
         /// <summary>
         /// Gets the guild of which this member is a part of.
         /// </summary>
         [JsonIgnore]
         public DiscordGuild Guild
             => this.Discord.Guilds[this._guild_id];
 
         /// <summary>
         /// Gets whether this member is the Guild owner.
         /// </summary>
         [JsonIgnore]
         public bool IsOwner
             => this.Id == this.Guild.OwnerId;
 
         /// <summary>
         /// Gets the member's position in the role hierarchy, which is the member's highest role's position. Returns <see cref="int.MaxValue"/> for the guild's owner.
         /// </summary>
         [JsonIgnore]
         public int Hierarchy
             => this.IsOwner ? int.MaxValue : this.RoleIds.Count == 0 ? 0 : this.Roles.Max(x => x.Position);
 
         /// <summary>
         /// Gets the permissions for the current member.
         /// </summary>
         [JsonIgnore]
         public Permissions Permissions => this.GetPermissions();
 
         #region Overridden user properties
         /// <summary>
         /// Gets the user.
         /// </summary>
         [JsonIgnore]
         internal DiscordUser User
             => this.Discord.UserCache[this.Id];
 
         /// <summary>
         /// Gets this member's username.
         /// </summary>
         public override string Username
         {
             get => this.User.Username;
             internal set => this.User.Username = value;
         }
 
         /// <summary>
         /// Gets the member's 4-digit discriminator.
         /// </summary>
         public override string Discriminator
         {
             get => this.User.Discriminator;
             internal set => this.User.Discriminator = value;
         }
 
         /// <summary>
         /// Gets the member's avatar hash.
         /// </summary>
         [JsonIgnore]
         public override string AvatarHash
         {
             get => this.User.AvatarHash;
             internal set => this.User.AvatarHash = value;
         }
 
         /// <summary>
         /// Gets whether the member is a bot.
         /// </summary>
         public override bool IsBot
         {
             get => this.User.IsBot;
             internal set => this.User.IsBot = value;
         }
 
         /// <summary>
         /// Gets the member's email address.
         /// <para>This is only present in OAuth.</para>
         /// </summary>
         public override string Email
         {
             get => this.User.Email;
             internal set => this.User.Email = value;
         }
 
         /// <summary>
         /// Gets whether the member has multi-factor authentication enabled.
         /// </summary>
         public override bool? MfaEnabled
         {
             get => this.User.MfaEnabled;
             internal set => this.User.MfaEnabled = value;
         }
 
         /// <summary>
         /// Gets whether the member is verified.
         /// <para>This is only present in OAuth.</para>
         /// </summary>
         public override bool? Verified
         {
             get => this.User.Verified;
             internal set => this.User.Verified = value;
         }
 
         /// <summary>
         /// Gets the member's chosen language
         /// </summary>
         public override string Locale
         {
             get => this.User.Locale;
             internal set => this.User.Locale = value;
         }
 
         /// <summary>
         /// Gets the user's flags.
         /// </summary>
         public override UserFlags? OAuthFlags
         {
             get => this.User.OAuthFlags;
             internal set => this.User.OAuthFlags = value;
         }
 
         /// <summary>
         /// Gets the member's flags for OAuth.
         /// </summary>
         public override UserFlags? Flags
         {
             get => this.User.Flags;
             internal set => this.User.Flags = value;
         }
         #endregion
 
         /// <summary>
         /// Creates a direct message channel to this member.
         /// </summary>
         /// <returns>Direct message channel to this member.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordDmChannel> CreateDmChannelAsync()
             => this.Discord.ApiClient.CreateDmAsync(this.Id);
 
         /// <summary>
         /// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> SendMessageAsync(string content)
         {
             if (this.IsBot && this.Discord.CurrentUser.IsBot)
                 throw new ArgumentException("Bots cannot DM each other.");
 
             var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
             return await chn.SendMessageAsync(content).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
         {
             if (this.IsBot && this.Discord.CurrentUser.IsBot)
                 throw new ArgumentException("Bots cannot DM each other.");
 
             var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
             return await chn.SendMessageAsync(embed).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
         {
             if (this.IsBot && this.Discord.CurrentUser.IsBot)
                 throw new ArgumentException("Bots cannot DM each other.");
 
             var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
             return await chn.SendMessageAsync(content, embed).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
         /// </summary>
         /// <param name="message">Builder to with the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder message)
         {
             if (this.IsBot && this.Discord.CurrentUser.IsBot)
                 throw new ArgumentException("Bots cannot DM each other.");
 
             var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
             return await chn.SendMessageAsync(message).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Sets this member's voice mute status.
         /// </summary>
         /// <param name="mute">Whether the member is to be muted.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task SetMuteAsync(bool mute, string reason = null)
             => this.Discord.ApiClient.ModifyGuildMemberAsync(this._guild_id, this.Id, default, default, mute, default, default, reason);
 
         /// <summary>
         /// Sets this member's voice deaf status.
         /// </summary>
         /// <param name="deaf">Whether the member is to be deafened.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.DeafenMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task SetDeafAsync(bool deaf, string reason = null)
             => this.Discord.ApiClient.ModifyGuildMemberAsync(this._guild_id, this.Id, default, default, default, deaf, default, reason);
 
         /// <summary>
         /// Modifies this member.
         /// </summary>
         /// <param name="action">Action to perform on this member.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageNicknames"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task ModifyAsync(Action<MemberEditModel> action)
         {
             var mdl = new MemberEditModel();
             action(mdl);
 
             if (mdl.VoiceChannel.HasValue && mdl.VoiceChannel.Value != null && mdl.VoiceChannel.Value.Type != ChannelType.Voice && mdl.VoiceChannel.Value.Type != ChannelType.Stage)
                 throw new ArgumentException("Given channel is not a voice or stage channel.", nameof(mdl.VoiceChannel));
 
             if (mdl.Nickname.HasValue && this.Discord.CurrentUser.Id == this.Id)
             {
                 await this.Discord.ApiClient.ModifyCurrentMemberNicknameAsync(this.Guild.Id, mdl.Nickname.Value,
                     mdl.AuditLogReason).ConfigureAwait(false);
 
                 await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, Optional.FromNoValue<string>(),
                     mdl.Roles.IfPresent(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
                     mdl.VoiceChannel.IfPresent(e => e?.Id), mdl.AuditLogReason).ConfigureAwait(false);
             }
             else
             {
                 await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, mdl.Nickname,
                     mdl.Roles.IfPresent(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
                     mdl.VoiceChannel.IfPresent(e => e?.Id), mdl.AuditLogReason).ConfigureAwait(false);
             }
         }
 
         /// <summary>
         /// Adds a timeout to a member.
         /// </summary>
         /// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
-        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
+        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task TimeoutAsync(DateTimeOffset until, string reason = null)
             => until.Subtract(DateTimeOffset.UtcNow).Days > 28 ? throw new ArgumentException("Timeout can not be longer than 28 days") : this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, until, reason);
 
         /// <summary>
         /// Adds a timeout to a member.
         /// </summary>
         /// <param name="until">The timespan to time out the user. Up to 28 days.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
-        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
+        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task TimeoutAsync(TimeSpan until, string reason = null)
             => this.TimeoutAsync(DateTimeOffset.UtcNow + until, reason);
 
         /// <summary>
         /// Adds a timeout to a member.
         /// </summary>
         /// <param name="until">The datetime to time out the user. Up to 28 days.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
-        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
+        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task TimeoutAsync(DateTime until, string reason = null)
             => this.TimeoutAsync(until.ToUniversalTime() - DateTime.UtcNow, reason);
 
         /// <summary>
         /// Removes the timeout from a member.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
-        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
+        /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveTimeoutAsync(string reason = null) => this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, null, reason);
 
         /// <summary>
         /// Grants a role to the member.
         /// </summary>
         /// <param name="role">Role to grant.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task GrantRoleAsync(DiscordRole role, string reason = null)
             => this.Discord.ApiClient.AddGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
         /// <summary>
         /// Revokes a role from a member.
         /// </summary>
         /// <param name="role">Role to revoke.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RevokeRoleAsync(DiscordRole role, string reason = null)
             => this.Discord.ApiClient.RemoveGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
         /// <summary>
         /// Sets the member's roles to ones specified.
         /// </summary>
         /// <param name="roles">Roles to set.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ReplaceRolesAsync(IEnumerable<DiscordRole> roles, string reason = null)
             => this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, default,
                 new Optional<IEnumerable<ulong>>(roles.Select(xr => xr.Id)), default, default, default, reason);
 
         /// <summary>
         /// Bans this member from their guild.
         /// </summary>
         /// <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="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanAsync(int delete_message_days = 0, string reason = null)
             => this.Guild.BanMemberAsync(this, delete_message_days, reason);
 
         /// <summary>
         /// Unbans this member from their guild.
         /// </summary>
         /// <exception cref = "Exceptions.UnauthorizedException" > Thrown when the client does not have the<see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanAsync(string reason = null) => this.Guild.UnbanMemberAsync(this, reason);
 
         /// <summary>
         /// Kicks this member from their guild.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <remarks>[alias="KickAsync"]</remarks>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveAsync(string reason = null)
             => this.Discord.ApiClient.RemoveGuildMemberAsync(this._guild_id, this.Id, reason);
 
         /// <summary>
         /// Moves this member to the specified voice channel
         /// </summary>
         /// <param name="channel"></param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task PlaceInAsync(DiscordChannel channel)
             => channel.PlaceMemberAsync(this);
 
         /// <summary>
         /// Updates the member's suppress state in a stage channel.
         /// </summary>
         /// <param name="channel">The channel the member is currently in.</param>
         /// <param name="suppress">Toggles the member's suppress state.</param>
         /// <exception cref="System.ArgumentException">Thrown when the channel in not a voice channel.</exception>
         public async Task UpdateVoiceStateAsync(DiscordChannel channel, bool? suppress)
         {
             if (channel.Type != ChannelType.Stage)
                 throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
             await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, channel.Id, suppress).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Makes the user a speaker.
         /// </summary>
         /// <exception cref="System.ArgumentException">Thrown when the user is not inside an stage channel.</exception>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task MakeSpeakerAsync()
         {
             var vs = this.VoiceState;
             if (vs == null || vs.Channel.Type != ChannelType.Stage)
                 throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
             await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, false).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Moves the user to audience.
         /// </summary>
         /// <exception cref="System.ArgumentException">Thrown when the user is not inside an stage channel.</exception>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task MoveToAudienceAsync()
         {
             var vs = this.VoiceState;
             if (vs == null || vs.Channel.Type != ChannelType.Stage)
                 throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
             await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, true).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Calculates permissions in a given channel for this member.
         /// </summary>
         /// <param name="channel">Channel to calculate permissions for.</param>
         /// <returns>Calculated permissions for this member in the channel.</returns>
         public Permissions PermissionsIn(DiscordChannel channel)
             => channel.PermissionsFor(this);
 
         /// <summary>
         /// Get's the current member's roles based on the sum of the permissions of their given roles.
         /// </summary>
         private Permissions GetPermissions()
         {
             if (this.Guild.OwnerId == this.Id)
                 return PermissionMethods.FULL_PERMS;
 
             Permissions perms;
 
             // assign @everyone permissions
             var everyoneRole = this.Guild.EveryoneRole;
             perms = everyoneRole.Permissions;
 
             // assign permissions from member's roles (in order)
             perms |= this.Roles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
             // Adminstrator grants all permissions and cannot be overridden
             return (perms & Permissions.Administrator) == Permissions.Administrator ? PermissionMethods.FULL_PERMS : perms;
         }
 
         /// <summary>
         /// Returns a string representation of this member.
         /// </summary>
         /// <returns>String representation of this member.</returns>
         public override string ToString() => $"Member {this.Id}; {this.Username}#{this.Discriminator} ({this.DisplayName})";
 
         /// <summary>
         /// Checks whether this <see cref="DiscordMember"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordMember"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordMember);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordMember"/> is equal to another <see cref="DiscordMember"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordMember"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordMember"/> is equal to this <see cref="DiscordMember"/>.</returns>
         public bool Equals(DiscordMember e) => e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this._guild_id == e._guild_id));
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordMember"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordMember"/>.</returns>
         public override int GetHashCode()
         {
             var hash = 13;
 
             hash = (hash * 7) + this.Id.GetHashCode();
             hash = (hash * 7) + this._guild_id.GetHashCode();
 
             return hash;
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordMember"/> objects are equal.
         /// </summary>
         /// <param name="e1">First member to compare.</param>
         /// <param name="e2">Second member to compare.</param>
         /// <returns>Whether the two members are equal.</returns>
         public static bool operator ==(DiscordMember e1, DiscordMember e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1._guild_id == e2._guild_id));
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordMember"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First member to compare.</param>
         /// <param name="e2">Second member to compare.</param>
         /// <returns>Whether the two members are not equal.</returns>
         public static bool operator !=(DiscordMember e1, DiscordMember e2)
             => !(e1 == e2);
     }
 }