diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index b56abce69..44521e7ad 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1366 +1,1369 @@
 // 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.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using DisCatSharp.ApplicationCommands.Attributes;
 using DisCatSharp.ApplicationCommands.EventArgs;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.ApplicationCommands
 {
     /// <summary>
     /// A class that handles slash commands for a client.
     /// </summary>
     public sealed class ApplicationCommandsExtension : BaseExtension
     {
         /// <summary>
         /// A list of methods for top level commands.
         /// </summary>
         private static List<CommandMethod> _commandMethods { get; set; } = new List<CommandMethod>();
 
         /// <summary>
         /// List of groups.
         /// </summary>
         private static List<GroupCommand> _groupCommands { get; set; } = new List<GroupCommand>();
 
         /// <summary>
         /// List of groups with subgroups.
         /// </summary>
         private static List<SubGroupCommand> _subGroupCommands { get; set; } = new List<SubGroupCommand>();
 
         /// <summary>
         /// List of context menus.
         /// </summary>
         private static List<ContextMenuCommand> _contextMenuCommands { get; set; } = new List<ContextMenuCommand>();
 
         /// <summary>
         /// Singleton modules.
         /// </summary>
         private static List<object> _singletonModules { get; set; } = new List<object>();
 
         /// <summary>
         /// List of modules to register.
         /// </summary>
         private List<KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>> _updateList { get; set; } = new List<KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>>();
 
         /// <summary>
         /// Configuration for Discord.
         /// </summary>
         private readonly ApplicationCommandsConfiguration _configuration;
 
         /// <summary>
         /// Set to true if anything fails when registering.
         /// </summary>
         private static bool _errored { get; set; } = false;
 
         /// <summary>
         /// Gets a list of registered commands. The key is the guild id (null if global).
         /// </summary>
         public IReadOnlyList<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> RegisteredCommands
             => _registeredCommands;
         private static List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> _registeredCommands = new();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ApplicationCommandsExtension"/> class.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
         internal ApplicationCommandsExtension(ApplicationCommandsConfiguration configuration)
         {
             this._configuration = configuration;
         }
 
         /// <summary>
         /// Runs setup. DO NOT RUN THIS MANUALLY. DO NOT DO ANYTHING WITH THIS.
         /// </summary>
         /// <param name="client">The client to setup on.</param>
         protected internal override void Setup(DiscordClient client)
         {
             if (this.Client != null)
                 throw new InvalidOperationException("What did I tell you?");
 
             this.Client = client;
 
             this._slashError = new AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs>("SLASHCOMMAND_ERRORED", TimeSpan.Zero, null);
             this._slashExecuted = new AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs>("SLASHCOMMAND_EXECUTED", TimeSpan.Zero, null);
             this._contextMenuErrored = new AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs>("CONTEXTMENU_ERRORED", TimeSpan.Zero, null);
             this._contextMenuExecuted = new AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs>("CONTEXTMENU_EXECUTED", TimeSpan.Zero, null);
 
             this.Client.Ready += this.Update;
             this.Client.InteractionCreated += this.InteractionHandler;
             this.Client.ContextMenuInteractionCreated += this.ContextMenuHandler;
         }
 
         /// <summary>
         /// Registers a command class.
         /// </summary>
         /// <typeparam name="T">The command class to register.</typeparam>
         /// <param name="guildId">The guild id to register it on. If you want global commands, leave it null.</param>
         public void RegisterCommands<T>(ulong? guildId = null) where T : ApplicationCommandsModule
         {
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T))));
         }
 
         /// <summary>
         /// Registers a command class.
         /// </summary>
         /// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
         /// <param name="guildId">The guild id to register it on. If you want global commands, leave it null.</param>
         public void RegisterCommands(Type type, ulong? guildId = null)
         {
             if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
                 throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
             //If sharding, only register for shard 0
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type)));
         }
 
         /// <summary>
         /// Registers a command class with permission setup.
         /// </summary>
         /// <typeparam name="T">The command class to register.</typeparam>
         /// <param name="guildId">The guild id to register it on.</param>
         /// <param name="permissionSetup">A callback to setup permissions with.</param>
         public void RegisterCommands<T>(ulong guildId, Action<ApplicationCommandsPermissionContext> permissionSetup = null) where T : ApplicationCommandsModule
         {
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), permissionSetup)));
         }
 
         /// <summary>
         /// Registers a command class with permission setup.
         /// </summary>
         /// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
         /// <param name="guildId">The guild id to register it on.</param>
         /// <param name="permissionSetup">A callback to setup permissions with.</param>
         public void RegisterCommands(Type type, ulong guildId, Action<ApplicationCommandsPermissionContext> permissionSetup = null)
         {
             if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
                 throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
             //If sharding, only register for shard 0
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type, permissionSetup)));
         }
         /*
         /// <summary>
         /// Registers a command class with permission setup but without a guild id.
         /// </summary>
         /// <typeparam name="T">The command class to register.</typeparam>
         /// <param name="permissionSetup">A callback to setup permissions with.</param>
         public void RegisterCommands<T>(Action<ApplicationCommandsPermissionContext> permissionSetup = null) where T : ApplicationCommandsModule
         {
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), permissionSetup)));
         }
 
         /// <summary>
         /// Registers a command class with permission setup but without a guild id.
         /// </summary>
         /// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
         /// <param name="permissionSetup">A callback to setup permissions with.</param>
         public void RegisterCommands(Type type, Action<ApplicationCommandsPermissionContext> permissionSetup = null)
         {
             if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
                 throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
             //If sharding, only register for shard 0
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type, permissionSetup)));
         }
         */
         /// <summary>
         /// To be run on ready.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <param name="e">The ready event args.</param>
         internal Task Update(DiscordClient client, ReadyEventArgs e)
             => this.Update();
 
         /// <summary>
         /// Actual method for registering, used for RegisterCommands and on Ready.
         /// </summary>
         internal Task Update()
         {
             //Only update for shard 0
             if (this.Client.ShardId == 0)
             {
                 //Groups commands by guild id or global
                 foreach (var key in this._updateList.Select(x => x.Key).Distinct())
                 {
                     this.RegisterCommands(this._updateList.Where(x => x.Key == key).Select(x => x.Value), key);
                 }
             }
             return Task.CompletedTask;
         }
 
         /// <summary>
         /// Method for registering commands for a target from modules.
         /// </summary>
         /// <param name="types">The types.</param>
         /// <param name="guildid">The optional guild id.</param>
         private void RegisterCommands(IEnumerable<ApplicationCommandsModuleConfiguration> types, ulong? guildid)
         {
             //Initialize empty lists to be added to the global ones at the end
             var commandMethods = new List<CommandMethod>();
             var groupCommands = new List<GroupCommand>();
             var subGroupCommands = new List<SubGroupCommand>();
             var contextMenuCommands = new List<ContextMenuCommand>();
             var updateList = new List<DiscordApplicationCommand>();
 
             var commandTypeSources = new List<KeyValuePair<Type, Type>>();
 
             _ = Task.Run(async () =>
             {
                 //Iterates over all the modules
                 foreach (var config in types)
                 {
                     var type = config.Type;
                     try
                     {
                         var module = type.GetTypeInfo();
                         var classes = new List<TypeInfo>();
 
                         //Add module to classes list if it's a group
                         if (module.GetCustomAttribute<SlashCommandGroupAttribute>() != null)
                         {
                             classes.Add(module);
                         }
                         else
                         {
                             //Otherwise add the nested groups
                             classes = module.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null).ToList();
                         }
 
                         //Handles groups
                         foreach (var subclassinfo in classes)
                         {
                             //Gets the attribute and methods in the group
                             var groupAttribute = subclassinfo.GetCustomAttribute<SlashCommandGroupAttribute>();
                             var submethods = subclassinfo.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
                             var subclasses = subclassinfo.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null);
                             if (subclasses.Any() && submethods.Any())
                             {
                                 throw new ArgumentException("Slash command groups cannot have both subcommands and subgroups!");
                             }
 
                             //Initializes the command
                             var payload = new DiscordApplicationCommand(groupAttribute.Name, groupAttribute.Description, default_permission: groupAttribute.DefaultPermission);
                             commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 
                             var commandmethods = new List<KeyValuePair<string, MethodInfo>>();
                             //Handles commands in the group
                             foreach (var submethod in submethods)
                             {
                                 var commandAttribute = submethod.GetCustomAttribute<SlashCommandAttribute>();
 
                                 //Gets the paramaters and accounts for InteractionContext
                                 var parameters = submethod.GetParameters();
                                 if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.First().ParameterType, typeof(InteractionContext)))
                                     throw new ArgumentException($"The first argument must be an InteractionContext!");
                                 parameters = parameters.Skip(1).ToArray();
 
                                 var options = await this.ParseParameters(parameters, guildid);
 
                                 //Creates the subcommand and adds it to the main command
                                 var subpayload = new DiscordApplicationCommandOption(commandAttribute.Name, commandAttribute.Description, ApplicationCommandOptionType.SubCommand, null, null, options);
                                 payload = new DiscordApplicationCommand(payload.Name, payload.Description, payload.Options?.Append(subpayload) ?? new[] { subpayload }, payload.DefaultPermission);
                                 commandTypeSources.Add(new KeyValuePair<Type, Type>(subclassinfo, type));
 
                                 //Adds it to the method lists
                                 commandmethods.Add(new KeyValuePair<string, MethodInfo>(commandAttribute.Name, submethod));
                                 groupCommands.Add(new GroupCommand { Name = groupAttribute.Name, Methods = commandmethods });
                             }
 
                             var command = new SubGroupCommand { Name = groupAttribute.Name };
                             //Handles subgroups
                             foreach (var subclass in subclasses)
                             {
                                 var subGroupAttribute = subclass.GetCustomAttribute<SlashCommandGroupAttribute>();
                                 //I couldn't think of more creative naming
                                 var subsubmethods = subclass.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
                                 var options = new List<DiscordApplicationCommandOption>();
 
                                 var currentMethods = new List<KeyValuePair<string, MethodInfo>>();
 
                                 //Similar to the one for regular groups
                                 foreach (var subsubmethod in subsubmethods)
                                 {
                                     var suboptions = new List<DiscordApplicationCommandOption>();
                                     var commatt = subsubmethod.GetCustomAttribute<SlashCommandAttribute>();
                                     var parameters = subsubmethod.GetParameters();
                                     if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.First().ParameterType, typeof(InteractionContext)))
                                         throw new ArgumentException($"The first argument must be an InteractionContext!");
                                     parameters = parameters.Skip(1).ToArray();
                                     suboptions = suboptions.Concat(await this.ParseParameters(parameters, guildid)).ToList();
 
                                     var subsubpayload = new DiscordApplicationCommandOption(commatt.Name, commatt.Description, ApplicationCommandOptionType.SubCommand, null, null, suboptions);
                                     options.Add(subsubpayload);
                                     commandmethods.Add(new KeyValuePair<string, MethodInfo>(commatt.Name, subsubmethod));
                                     currentMethods.Add(new KeyValuePair<string, MethodInfo>(commatt.Name, subsubmethod));
                                 }
 
                                 //Adds the group to the command and method lists
                                 var subpayload = new DiscordApplicationCommandOption(subGroupAttribute.Name, subGroupAttribute.Description, ApplicationCommandOptionType.SubCommandGroup, null, null, options);
                                 command.SubCommands.Add(new GroupCommand { Name = subGroupAttribute.Name, Methods = currentMethods });
                                 payload = new DiscordApplicationCommand(payload.Name, payload.Description, payload.Options?.Append(subpayload) ?? new[] { subpayload }, payload.DefaultPermission);
                                 commandTypeSources.Add(new KeyValuePair<Type, Type>(subclass, type));
 
                                 //Accounts for lifespans for the sub group
                                 if (subclass.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null)
                                 {
                                     if (subclass.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
                                     {
                                         _singletonModules.Add(this.CreateInstance(subclass, this._configuration?.ServiceProvider));
                                     }
                                 }
                             }
                             if (command.SubCommands.Any()) subGroupCommands.Add(command);
                             updateList.Add(payload);
 
                             //Accounts for lifespans
                             if (subclassinfo.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null)
                             {
                                 if (subclassinfo.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
                                 {
                                     _singletonModules.Add(this.CreateInstance(subclassinfo, this._configuration?.ServiceProvider));
                                 }
                             }
                         }
 
                         //Handles methods and context menus, only if the module isn't a group itself
                         if (module.GetCustomAttribute<SlashCommandGroupAttribute>() == null)
                         {
                             //Slash commands (again, similar to the one for groups)
                             var methods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
                             foreach (var method in methods)
                             {
                                 var commandattribute = method.GetCustomAttribute<SlashCommandAttribute>();
 
                                 var parameters = method.GetParameters();
                                 if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.FirstOrDefault()?.ParameterType, typeof(InteractionContext)))
                                     throw new ArgumentException($"The first argument must be an InteractionContext!");
                                 parameters = parameters.Skip(1).ToArray();
                                 var options = await this.ParseParameters(parameters, guildid);
 
                                 commandMethods.Add(new CommandMethod { Method = method, Name = commandattribute.Name });
 
                                 var payload = new DiscordApplicationCommand(commandattribute.Name, commandattribute.Description, options, commandattribute.DefaultPermission);
                                 updateList.Add(payload);
                                 commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
                             }
 
                             //Context Menus
                             var contextMethods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<ContextMenuAttribute>() != null);
                             foreach (var contextMethod in contextMethods)
                             {
                                 var contextAttribute = contextMethod.GetCustomAttribute<ContextMenuAttribute>();
                                 var command = new DiscordApplicationCommand(contextAttribute.Name, null, type: contextAttribute.Type, default_permission: contextAttribute.DefaultPermission);
 
                                 var parameters = contextMethod.GetParameters();
                                 if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.FirstOrDefault()?.ParameterType, typeof(ContextMenuContext)))
                                     throw new ArgumentException($"The first argument must be a ContextMenuContext!");
                                 if (parameters.Length > 1)
                                     throw new ArgumentException($"A context menu cannot have parameters!");
 
                                 contextMenuCommands.Add(new ContextMenuCommand { Method = contextMethod, Name = contextAttribute.Name });
 
                                 updateList.Add(command);
                                 commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
                             }
 
                             //Accounts for lifespans
                             if (module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null)
                             {
                                 if (module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
                                 {
                                     _singletonModules.Add(this.CreateInstance(module, this._configuration?.ServiceProvider));
                                 }
                             }
                         }
                     }
                     catch (Exception ex)
                     {
                         //This isn't really much more descriptive but I added a separate case for it anyway
                         if (ex is BadRequestException brex)
                             this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.JsonMessage}");
                         else
                             this.Client.Logger.LogCritical(ex, $"There was an error registering application commands");
                         _errored = true;
                     }
                 }
                 if (!_errored)
                 {
                     try
                     {
                         async Task UpdateCommandPermission(ulong commandId, string commandName, Type commandDeclaringType, Type commandRootType)
                         {
                             if (guildid == null)
                             {
                                 //throw new NotImplementedException("You can't set global permissions till yet. See https://discord.com/developers/docs/interactions/application-commands#permissions");
                             }
                             else
                             {
                                 var ctx = new ApplicationCommandsPermissionContext(commandDeclaringType, commandName);
                                 var conf = types.First(t => t.Type == commandRootType);
                                 conf.Setup?.Invoke(ctx);
 
                                 if (ctx.Permissions.Count == 0)
                                     return;
 
                                 await this.Client.OverwriteGuildApplicationCommandPermissionsAsync(guildid.Value, commandId, ctx.Permissions);
                             }
                         }
 
                         async Task UpdateCommandPermissionGroup(GroupCommand groupCommand)
                         {
                             foreach (var com in groupCommand.Methods)
                             {
                                 var source = commandTypeSources.FirstOrDefault(f => f.Key == com.Value.DeclaringType);
 
                                 await UpdateCommandPermission(groupCommand.CommandId, com.Key, source.Key, source.Value);
                             }
                         }
 
                         var commands = guildid == null
                             ? await this.Client.BulkOverwriteGlobalApplicationCommandsAsync(updateList)
                             : (IEnumerable<DiscordApplicationCommand>)await this.Client.BulkOverwriteGuildApplicationCommandsAsync(guildid.Value, updateList);
 
                         //Creates a guild command if a guild id is specified, otherwise global
                         //Checks against the ids and adds them to the command method lists
                         foreach (var command in commands)
                         {
                             if (commandMethods.Any(x => x.Name == command.Name))
                             {
                                 var com = commandMethods.First(x => x.Name == command.Name);
                                 com.CommandId = command.Id;
 
                                 var source = commandTypeSources.FirstOrDefault(f => f.Key == com.Method.DeclaringType);
                                 await UpdateCommandPermission(command.Id, com.Name, source.Value, source.Key);
                             }
 
                             else if (groupCommands.Any(x => x.Name == command.Name))
                             {
                                 var com = groupCommands.First(x => x.Name == command.Name);
                                 com.CommandId = command.Id;
 
                                 await UpdateCommandPermissionGroup(com);
                             }
 
                             else if (subGroupCommands.Any(x => x.Name == command.Name))
                             {
                                 var com = subGroupCommands.First(x => x.Name == command.Name);
                                 com.CommandId = command.Id;
 
                                 foreach (var groupComs in com.SubCommands)
                                     await UpdateCommandPermissionGroup(groupComs);
                             }
 
                             else if (contextMenuCommands.Any(x => x.Name == command.Name))
                             {
                                 var com = contextMenuCommands.First(x => x.Name == command.Name);
                                 com.CommandId = command.Id;
 
                                 var source = commandTypeSources.First(f => f.Key == com.Method.DeclaringType);
                                 await UpdateCommandPermission(command.Id, com.Name, source.Value, source.Key);
                             }
                         }
 
                         //Adds to the global lists finally
                         _commandMethods.AddRange(commandMethods);
                         _groupCommands.AddRange(groupCommands);
                         _subGroupCommands.AddRange(subGroupCommands);
                         _contextMenuCommands.AddRange(contextMenuCommands);
 
                         _registeredCommands.Add(new KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>(guildid, commands.ToList()));
 
                         foreach (var command in commandMethods)
                         {
                             var app = types.First(t => t.Type == command.Method.DeclaringType);
                         }
                     }
                     catch (Exception ex)
                     {
                         if (ex is BadRequestException brex)
                             this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.JsonMessage}");
                         else
                             this.Client.Logger.LogCritical(ex, $"There was an error registering application commands");
                         _errored = true;
                     }
                 }
             });
         }
 
         /// <summary>
         /// Interaction handler.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <param name="e">The event args.</param>
         private Task InteractionHandler(DiscordClient client, InteractionCreateEventArgs e)
         {
             _ = Task.Run(async () =>
             {
                 if (e.Interaction.Type == InteractionType.ApplicationCommand)
                 {
                     //Creates the context
                     var context = new InteractionContext
                     {
                         Interaction = e.Interaction,
                         Channel = e.Interaction.Channel,
                         Guild = e.Interaction.Guild,
                         User = e.Interaction.User,
                         Client = client,
                         ApplicationCommandsExtension = this,
                         CommandName = e.Interaction.Data.Name,
                         InteractionId = e.Interaction.Id,
                         Token = e.Interaction.Token,
                         Services = this._configuration?.ServiceProvider,
                         ResolvedUserMentions = e.Interaction.Data.Resolved?.Users?.Values.ToList(),
                         ResolvedRoleMentions = e.Interaction.Data.Resolved?.Roles?.Values.ToList(),
                         ResolvedChannelMentions = e.Interaction.Data.Resolved?.Channels?.Values.ToList(),
+                        Attachments = e.Interaction.Data.Attachments?.ToList(),
                         Type = ApplicationCommandType.ChatInput
                     };
 
                     try
                     {
                         if (_errored)
                             throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
                         var methods = _commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
                         var groups = _groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
                         var subgroups = _subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
                         if (!methods.Any() && !groups.Any() && !subgroups.Any())
                             throw new InvalidOperationException("A slash command was executed, but no command was registered for it.");
 
                         if (methods.Any())
                         {
                             var method = methods.First().Method;
 
                             var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options);
 
                             await this.RunCommandAsync(context, method, args);
                         }
                         else if (groups.Any())
                         {
                             var command = e.Interaction.Data.Options.First();
                             var method = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
                             var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options);
 
                             await this.RunCommandAsync(context, method, args);
                         }
                         else if (subgroups.Any())
                         {
                             var command = e.Interaction.Data.Options.First();
                             var group = subgroups.First().SubCommands.First(x => x.Name == command.Name);
 
                             var method = group.Methods.First(x => x.Key == command.Options.First().Name).Value;
 
                             var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options.First().Options);
 
                             await this.RunCommandAsync(context, method, args);
                         }
 
                         await this._slashExecuted.InvokeAsync(this, new SlashCommandExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
                     }
                     catch (Exception ex)
                     {
                         await this._slashError.InvokeAsync(this, new SlashCommandErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
                     }
                 }
                 else if (e.Interaction.Type == InteractionType.AutoComplete)
                 {
                     if (_errored)
                         throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
                     var methods = _commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
                     var groups = _groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
                     var subgroups = _subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
                     if (!methods.Any() && !groups.Any() && !subgroups.Any())
                         throw new InvalidOperationException("An autocomplete interaction was created, but no command was registered for it.");
 
                     try
                     {
                         if (methods.Any())
                         {
                             var focusedOption = e.Interaction.Data.Options.First(o => o.Focused);
                             var method = methods.First().Method;
 
                             var option = method.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
                             var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
                             var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
                             var providerInstance = Activator.CreateInstance(provider);
 
                             var context = new AutocompleteContext
                             {
                                 Interaction = e.Interaction,
                                 Client = this.Client,
                                 Services = this._configuration?.ServiceProvider,
                                 ApplicationCommandsExtension = this,
                                 Guild = e.Interaction.Guild,
                                 Channel = e.Interaction.Channel,
                                 User = e.Interaction.User,
                                 Options = e.Interaction.Data.Options.ToList(),
                                 FocusedOption = focusedOption
                             };
 
                             var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
                             await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
                         }
                         else if (groups.Any())
                         {
                             var command = e.Interaction.Data.Options.First();
                             var group = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
                             var focusedOption = command.Options.First(o => o.Focused);
                             var option = group.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
                             var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
                             var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
                             var providerInstance = Activator.CreateInstance(provider);
 
                             var context = new AutocompleteContext
                             {
                                 Interaction = e.Interaction,
                                 Services = this._configuration?.ServiceProvider,
                                 ApplicationCommandsExtension = this,
                                 Guild = e.Interaction.Guild,
                                 Channel = e.Interaction.Channel,
                                 User = e.Interaction.User,
                                 Options = command.Options.ToList(),
                                 FocusedOption = focusedOption
                             };
 
                             var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
                             await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
                         }
                         /*else if (subgroups.Any())
                         {
                             var command = e.Interaction.Data.Options.First();
                             var method = methods.First().Method;
                             var group = subgroups.First().SubCommands.First(x => x.Name == command.Name);
 
                             var focusedOption = command.Options.First(x => x.Name == group.Name).Options.First(o => o.Focused);
                             this.Client.Logger.LogDebug("SUBGROUP::" + focusedOption.Name + ": " + focusedOption.RawValue);
 
                             var option = group.Methods.First(p => p.Value.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name).Value;
                             var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
                             var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
                             var providerInstance = Activator.CreateInstance(provider);
 
                             var context = new AutocompleteContext
                             {
                                 Interaction = e.Interaction,
                                 Services = this._configuration?.Services,
                                 ApplicationCommandsExtension = this,
                                 Guild = e.Interaction.Guild,
                                 Channel = e.Interaction.Channel,
                                 User = e.Interaction.User,
                                 Options = command.Options.First(x => x.Name == group.Name).Options.ToList(),
                                 FocusedOption = focusedOption
                             };
 
                             var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
                             await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
                         }*/
                     }
                     catch (Exception ex)
                     {
                         this.Client.Logger.LogError(ex, "Error in autocomplete interaction");
                     }
                 }
             });
             return Task.CompletedTask;
         }
 
         /// <summary>
         /// Context menu handler.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <param name="e">The event args.</param>
         private Task ContextMenuHandler(DiscordClient client, ContextMenuInteractionCreateEventArgs e)
         {
             _ = Task.Run(async () =>
             {
                 //Creates the context
                 var context = new ContextMenuContext
                 {
                     Interaction = e.Interaction,
                     Channel = e.Interaction.Channel,
                     Client = client,
                     Services = this._configuration?.ServiceProvider,
                     CommandName = e.Interaction.Data.Name,
                     ApplicationCommandsExtension = this,
                     Guild = e.Interaction.Guild,
                     InteractionId = e.Interaction.Id,
                     User = e.Interaction.User,
                     Token = e.Interaction.Token,
                     TargetUser = e.TargetUser,
                     TargetMessage = e.TargetMessage,
                     Type = e.Type
                 };
 
                 try
                 {
                     if (_errored)
                         throw new InvalidOperationException("Context menus failed to register properly on startup.");
 
                     //Gets the method for the command
                     var method = _contextMenuCommands.FirstOrDefault(x => x.CommandId == e.Interaction.Data.Id);
 
                     if (method == null)
                         throw new InvalidOperationException("A context menu was executed, but no command was registered for it.");
 
                     await this.RunCommandAsync(context, method.Method, new[] { context });
 
                     await this._contextMenuExecuted.InvokeAsync(this, new ContextMenuExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
                 }
                 catch (Exception ex)
                 {
                     await this._contextMenuErrored.InvokeAsync(this, new ContextMenuErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
                 }
             });
 
             return Task.CompletedTask;
         }
 
         /// <summary>
         /// Runs a command.
         /// </summary>
         /// <param name="context">The base context.</param>
         /// <param name="method">The method info.</param>
         /// <param name="args">The arguments.</param>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0066:Convert switch statement to expression", Justification = "<Pending>")]
         internal async Task RunCommandAsync(BaseContext context, MethodInfo method, IEnumerable<object> args)
         {
             object classInstance;
 
             //Accounts for lifespans
             var moduleLifespan = (method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null ? method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>()?.Lifespan : ApplicationCommandModuleLifespan.Transient) ?? ApplicationCommandModuleLifespan.Transient;
             switch (moduleLifespan)
             {
                 case ApplicationCommandModuleLifespan.Scoped:
                     //Accounts for static methods and adds DI
                     classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(this._configuration?.ServiceProvider.CreateScope().ServiceProvider, method.DeclaringType) : this.CreateInstance(method.DeclaringType, this._configuration?.ServiceProvider.CreateScope().ServiceProvider);
                     break;
 
                 case ApplicationCommandModuleLifespan.Transient:
                     //Accounts for static methods and adds DI
                     classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(this._configuration?.ServiceProvider, method.DeclaringType) : this.CreateInstance(method.DeclaringType, this._configuration?.ServiceProvider);
                     break;
 
                 //If singleton, gets it from the singleton list
                 case ApplicationCommandModuleLifespan.Singleton:
                     classInstance = _singletonModules.First(x => ReferenceEquals(x.GetType(), method.DeclaringType));
                     break;
 
                 default:
                     throw new Exception($"An unknown {nameof(ApplicationCommandModuleLifespanAttribute)} scope was specified on command {context.CommandName}");
             }
 
             ApplicationCommandsModule module = null;
             if (classInstance is ApplicationCommandsModule mod)
                 module = mod;
 
             // Slash commands
             if (context is InteractionContext slashContext)
             {
                 await this.RunPreexecutionChecksAsync(method, slashContext);
 
                 var shouldExecute = await (module?.BeforeSlashExecutionAsync(slashContext) ?? Task.FromResult(true));
 
                 if (shouldExecute)
                 {
                     await (Task)method.Invoke(classInstance, args.ToArray());
 
                     await (module?.AfterSlashExecutionAsync(slashContext) ?? Task.CompletedTask);
                 }
             }
             // Context menus
             if (context is ContextMenuContext contextMenuContext)
             {
                 await this.RunPreexecutionChecksAsync(method, contextMenuContext);
 
                 var shouldExecute = await (module?.BeforeContextMenuExecutionAsync(contextMenuContext) ?? Task.FromResult(true));
 
                 if (shouldExecute)
                 {
                     await (Task)method.Invoke(classInstance, args.ToArray());
 
                     await (module?.AfterContextMenuExecutionAsync(contextMenuContext) ?? Task.CompletedTask);
                 }
             }
         }
 
         /// <summary>
         /// Property injection copied over from CommandsNext
         /// </summary>
         /// <param name="t">The type.</param>
         /// <param name="services">The services.</param>
         internal object CreateInstance(Type t, IServiceProvider services)
         {
             var ti = t.GetTypeInfo();
             var constructors = ti.DeclaredConstructors
                 .Where(xci => xci.IsPublic)
                 .ToArray();
 
             if (constructors.Length != 1)
                 throw new ArgumentException("Specified type does not contain a public constructor or contains more than one public constructor.");
 
             var constructor = constructors[0];
             var constructorArgs = constructor.GetParameters();
             var args = new object[constructorArgs.Length];
 
             if (constructorArgs.Length != 0 && services == null)
                 throw new InvalidOperationException("Dependency collection needs to be specified for parameterized constructors.");
 
             // inject via constructor
             if (constructorArgs.Length != 0)
                 for (var i = 0; i < args.Length; i++)
                     args[i] = services.GetRequiredService(constructorArgs[i].ParameterType);
 
             var moduleInstance = Activator.CreateInstance(t, args);
 
             // inject into properties
             var props = t.GetRuntimeProperties().Where(xp => xp.CanWrite && xp.SetMethod != null && !xp.SetMethod.IsStatic && xp.SetMethod.IsPublic);
             foreach (var prop in props)
             {
                 if (prop.GetCustomAttribute<DontInjectAttribute>() != null)
                     continue;
 
                 var service = services.GetService(prop.PropertyType);
                 if (service == null)
                     continue;
 
                 prop.SetValue(moduleInstance, service);
             }
 
             // inject into fields
             var fields = t.GetRuntimeFields().Where(xf => !xf.IsInitOnly && !xf.IsStatic && xf.IsPublic);
             foreach (var field in fields)
             {
                 if (field.GetCustomAttribute<DontInjectAttribute>() != null)
                     continue;
 
                 var service = services.GetService(field.FieldType);
                 if (service == null)
                     continue;
 
                 field.SetValue(moduleInstance, service);
             }
 
             return moduleInstance;
         }
 
         /// <summary>
         /// Resolves the slash command parameters.
         /// </summary>
         /// <param name="e">The event arguments.</param>
         /// <param name="context">The interaction context.</param>
         /// <param name="method">The method info.</param>
         /// <param name="options">The options.</param>
         private async Task<List<object>> ResolveInteractionCommandParameters(InteractionCreateEventArgs e, InteractionContext context, MethodInfo method, IEnumerable<DiscordInteractionDataOption> options)
         {
             var args = new List<object> { context };
             var parameters = method.GetParameters().Skip(1);
 
             for (var i = 0; i < parameters.Count(); i++)
             {
                 var parameter = parameters.ElementAt(i);
 
                 //Accounts for optional arguments without values given
                 if (parameter.IsOptional && (options == null ||
                                              (!options?.Any(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower()) ?? true)))
                     args.Add(parameter.DefaultValue);
                 else
                 {
                     var option = options.Single(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower());
 
                     //Checks the type and casts/references resolved and adds the value to the list
                     //This can probably reference the slash command's type property that didn't exist when I wrote this and it could use a cleaner switch instead, but if it works it works
                     if (parameter.ParameterType == typeof(string))
                         args.Add(option.Value.ToString());
                     else if (parameter.ParameterType.IsEnum)
                         args.Add(Enum.Parse(parameter.ParameterType, (string)option.Value));
                     else if (parameter.ParameterType == typeof(long) || parameter.ParameterType == typeof(long?))
                         args.Add((long?)option.Value);
                     else if (parameter.ParameterType == typeof(bool) || parameter.ParameterType == typeof(bool?))
                         args.Add((bool?)option.Value);
                     else if (parameter.ParameterType == typeof(double) || parameter.ParameterType == typeof(double?))
                         args.Add((double?)option.Value);
+                    else if (parameter.ParameterType == typeof(DiscordAttachment))
+                        args.Add(context.Attachments.ElementAt((int)option.Value));
                     else if (parameter.ParameterType == typeof(DiscordUser))
                     {
                         //Checks through resolved
                         if (e.Interaction.Data.Resolved.Members != null &&
                             e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
                             args.Add(member);
                         else if (e.Interaction.Data.Resolved.Users != null &&
                                  e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
                             args.Add(user);
                         else
                             args.Add(await this.Client.GetUserAsync((ulong)option.Value));
                     }
                     else if (parameter.ParameterType == typeof(DiscordChannel))
                     {
                         //Checks through resolved
                         if (e.Interaction.Data.Resolved.Channels != null &&
                             e.Interaction.Data.Resolved.Channels.TryGetValue((ulong)option.Value, out var channel))
                             args.Add(channel);
                         else
                             args.Add(e.Interaction.Guild.GetChannel((ulong)option.Value));
                     }
                     else if (parameter.ParameterType == typeof(DiscordRole))
                     {
                         //Checks through resolved
                         if (e.Interaction.Data.Resolved.Roles != null &&
                             e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
                             args.Add(role);
                         else
                             args.Add(e.Interaction.Guild.GetRole((ulong)option.Value));
                     }
                     else if (parameter.ParameterType == typeof(SnowflakeObject))
                     {
                         //Checks through resolved
                         if (e.Interaction.Data.Resolved.Roles != null && e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
                             args.Add(role);
                         else if (e.Interaction.Data.Resolved.Members != null && e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
                             args.Add(member);
                         else if (e.Interaction.Data.Resolved.Users != null && e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
                             args.Add(user);
                         else
                             throw new ArgumentException("Error resolving mentionable option.");
                     }
                     else
                         throw new ArgumentException($"Error resolving interaction.");
                 }
             }
 
             return args;
         }
 
         /// <summary>
         /// Runs the preexecution checks.
         /// </summary>
         /// <param name="method">The method info.</param>
         /// <param name="context">The basecontext.</param>
         private async Task RunPreexecutionChecksAsync(MethodInfo method, BaseContext context)
         {
             if (context is InteractionContext ctx)
             {
                 //Gets all attributes from parent classes as well and stuff
                 var attributes = new List<SlashCheckBaseAttribute>();
                 attributes.AddRange(method.GetCustomAttributes<SlashCheckBaseAttribute>(true));
                 attributes.AddRange(method.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
                 if (method.DeclaringType.DeclaringType != null)
                 {
                     attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
                     if (method.DeclaringType.DeclaringType.DeclaringType != null)
                     {
                         attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
                     }
                 }
 
                 var dict = new Dictionary<SlashCheckBaseAttribute, bool>();
                 foreach (var att in attributes)
                 {
                     //Runs the check and adds the result to a list
                     var result = await att.ExecuteChecksAsync(ctx);
                     dict.Add(att, result);
                 }
 
                 //Checks if any failed, and throws an exception
                 if (dict.Any(x => x.Value == false))
                     throw new SlashExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
             }
             if (context is ContextMenuContext CMctx)
             {
                 var attributes = new List<ContextMenuCheckBaseAttribute>();
                 attributes.AddRange(method.GetCustomAttributes<ContextMenuCheckBaseAttribute>(true));
                 attributes.AddRange(method.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
                 if (method.DeclaringType.DeclaringType != null)
                 {
                     attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
                     if (method.DeclaringType.DeclaringType.DeclaringType != null)
                     {
                         attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
                     }
                 }
 
                 var dict = new Dictionary<ContextMenuCheckBaseAttribute, bool>();
                 foreach (var att in attributes)
                 {
                     //Runs the check and adds the result to a list
                     var result = await att.ExecuteChecksAsync(CMctx);
                     dict.Add(att, result);
                 }
 
                 //Checks if any failed, and throws an exception
                 if (dict.Any(x => x.Value == false))
                     throw new ContextMenuExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
             }
         }
 
         /// <summary>
         /// Gets the choice attributes from choice provider.
         /// </summary>
         /// <param name="customAttributes">The custom attributes.</param>
         /// <param name="guildId"></param>
         private async Task<List<DiscordApplicationCommandOptionChoice>> GetChoiceAttributesFromProvider(IEnumerable<ChoiceProviderAttribute> customAttributes, ulong? guildId = null)
         {
             var choices = new List<DiscordApplicationCommandOptionChoice>();
             foreach (var choiceProviderAttribute in customAttributes)
             {
                 var method = choiceProviderAttribute.ProviderType.GetMethod(nameof(IChoiceProvider.Provider));
 
                 if (method == null)
                     throw new ArgumentException("ChoiceProviders must inherit from IChoiceProvider.");
                 else
                 {
                     var instance = Activator.CreateInstance(choiceProviderAttribute.ProviderType);
 
                     // Abstract class offers more properties that can be set
                     if (choiceProviderAttribute.ProviderType.IsSubclassOf(typeof(ChoiceProvider)))
                     {
                         choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.GuildId))
                             ?.SetValue(instance, guildId);
 
                         choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.Services))
                             ?.SetValue(instance, _configuration.ServiceProvider);
                     }
 
                     //Gets the choices from the method
                     var result = await (Task<IEnumerable<DiscordApplicationCommandOptionChoice>>)method.Invoke(instance, null);
 
                     if (result.Any())
                     {
                         choices.AddRange(result);
                     }
                 }
             }
 
             return choices;
         }
         /// <summary>
         /// Gets the choice attributes from enum parameter.
         /// </summary>
         /// <param name="enumParam">The enum parameter.</param>
         private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromEnumParameter(Type enumParam)
         {
             var choices = new List<DiscordApplicationCommandOptionChoice>();
             foreach (Enum enumValue in Enum.GetValues(enumParam))
             {
                 choices.Add(new DiscordApplicationCommandOptionChoice(enumValue.GetName(), enumValue.ToString()));
             }
             return choices;
         }
 
         /// <summary>
         /// Gets the parameter type.
         /// </summary>
         /// <param name="type">The type.</param>
         private ApplicationCommandOptionType GetParameterType(Type type)
         {
             var parametertype = type == typeof(string)
                 ? ApplicationCommandOptionType.String
                 : type == typeof(long) || type == typeof(long?)
                 ? ApplicationCommandOptionType.Integer
                 : type == typeof(bool) || type == typeof(bool?)
                 ? ApplicationCommandOptionType.Boolean
                 : type == typeof(double) || type == typeof(double?)
                 ? ApplicationCommandOptionType.Number
                 : type == typeof(DiscordChannel)
                 ? ApplicationCommandOptionType.Channel
                 : type == typeof(DiscordUser)
                 ? ApplicationCommandOptionType.User
                 : type == typeof(DiscordRole)
                 ? ApplicationCommandOptionType.Role
                 : type == typeof(SnowflakeObject)
                 ? ApplicationCommandOptionType.Mentionable
                 : type == typeof(DiscordAttachment)
                 ? ApplicationCommandOptionType.Attachment
                 : type.IsEnum
                 ? ApplicationCommandOptionType.String
                 : throw new ArgumentException("Cannot convert type! Argument types must be string, long, bool, double, DiscordChannel, DiscordUser, DiscordRole, SnowflakeObject, DiscordAttachment or an Enum.");
             return parametertype;
         }
 
         /// <summary>
         /// Gets the choice attributes from parameter.
         /// </summary>
         /// <param name="choiceattributes">The choice attributes.</param>
         private List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromParameter(IEnumerable<ChoiceAttribute> choiceattributes)
         {
             return !choiceattributes.Any()
                 ? null
                 : choiceattributes.Select(att => new DiscordApplicationCommandOptionChoice(att.Name, att.Value)).ToList();
         }
 
         /// <summary>
         /// Parses the parameters.
         /// </summary>
         /// <param name="parameters">The parameters.</param>
         /// <param name="guildId">The guild id.</param>
         /// <returns>A Task.</returns>
         private async Task<List<DiscordApplicationCommandOption>> ParseParameters(ParameterInfo[] parameters, ulong? guildId)
         {
             var options = new List<DiscordApplicationCommandOption>();
             foreach (var parameter in parameters)
             {
                 //Gets the attribute
                 var optionattribute = parameter.GetCustomAttribute<OptionAttribute>();
                 if (optionattribute == null)
                     throw new ArgumentException("Arguments must have the Option attribute!");
 
                 var minimumValue = parameter.GetCustomAttribute<MinimumAttribute>()?.Value ?? null;
                 var maximumValue = parameter.GetCustomAttribute<MaximumAttribute>()?.Value ?? null;
 
 
                 var autocompleteAttribute = parameter.GetCustomAttribute<AutocompleteAttribute>();
                 if (optionattribute.Autocomplete && autocompleteAttribute == null)
                     throw new ArgumentException("Autocomplete options must have the Autocomplete attribute!");
                 if (!optionattribute.Autocomplete && autocompleteAttribute != null)
                     throw new ArgumentException("Setting an autocomplete provider requires the option to have autocomplete set to true!");
 
                 //Sets the type
                 var type = parameter.ParameterType;
                 var parametertype = this.GetParameterType(type);
 
                 //Handles choices
                 //From attributes
                 var choices = this.GetChoiceAttributesFromParameter(parameter.GetCustomAttributes<ChoiceAttribute>());
                 //From enums
                 if (parameter.ParameterType.IsEnum)
                 {
                     choices = GetChoiceAttributesFromEnumParameter(parameter.ParameterType);
                 }
                 //From choice provider
                 var choiceProviders = parameter.GetCustomAttributes<ChoiceProviderAttribute>();
                 if (choiceProviders.Any())
                 {
                     choices = await this.GetChoiceAttributesFromProvider(choiceProviders, guildId);
                 }
 
                 var channelTypes = parameter.GetCustomAttribute<ChannelTypesAttribute>()?.ChannelTypes ?? null;
 
                 options.Add(new DiscordApplicationCommandOption(optionattribute.Name, optionattribute.Description, parametertype, !parameter.IsOptional, choices, null, channelTypes, optionattribute.Autocomplete, minimumValue, maximumValue));
             }
 
             return options;
         }
 
         /// <summary>
         /// <para>Refreshes your commands, used for refreshing choice providers or applying commands registered after the ready event on the discord client.
         /// Should only be run on the slash command extension linked to shard 0 if sharding.</para>
         /// <para>Not recommended and should be avoided since it can make slash commands be unresponsive for a while.</para>
         /// </summary>
         public async Task RefreshCommandsAsync()
         {
             _commandMethods.Clear();
             _groupCommands.Clear();
             _subGroupCommands.Clear();
             _registeredCommands.Clear();
             _contextMenuCommands.Clear();
 
             await this.Update();
         }
 
         /// <summary>
         /// Fires when the execution of a slash command fails.
         /// </summary>
         public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandErrorEventArgs> SlashCommandErrored
         {
             add { this._slashError.Register(value); }
             remove { this._slashError.Unregister(value); }
         }
         private AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs> _slashError;
 
         /// <summary>
         /// Fires when the execution of a slash command is successful.
         /// </summary>
         public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> SlashCommandExecuted
         {
             add { this._slashExecuted.Register(value); }
             remove { this._slashExecuted.Unregister(value); }
         }
         private AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> _slashExecuted;
 
         /// <summary>
         /// Fires when the execution of a context menu fails.
         /// </summary>
         public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuErrorEventArgs> ContextMenuErrored
         {
             add { this._contextMenuErrored.Register(value); }
             remove { this._contextMenuErrored.Unregister(value); }
         }
         private AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs> _contextMenuErrored;
 
         /// <summary>
         /// Fire when the execution of a context menu is successful.
         /// </summary>
         public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> ContextMenuExecuted
         {
             add { this._contextMenuExecuted.Register(value); }
             remove { this._contextMenuExecuted.Unregister(value); }
         }
         private AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> _contextMenuExecuted;
     }
 
     /// <summary>
     /// Holds configuration data for setting up an application command.
     /// </summary>
     internal class ApplicationCommandsModuleConfiguration
     {
         /// <summary>
         /// The type of the command module.
         /// </summary>
         public Type Type { get; }
 
         /// <summary>
         /// The permission setup.
         /// </summary>
         public Action<ApplicationCommandsPermissionContext> Setup { get; }
 
         /// <summary>
         /// Creates a new command configuration.
         /// </summary>
         /// <param name="type">The type of the command module.</param>
         /// <param name="setup">The permission setup callback.</param>
         public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsPermissionContext> setup = null)
         {
             this.Type = type;
             this.Setup = setup;
         }
     }
 
     /// <summary>
     /// Links a command to its original command module.
     /// </summary>
     internal class ApplicationCommandSourceLink
     {
         /// <summary>
         /// The command.
         /// </summary>
         public DiscordApplicationCommand ApplicationCommand { get; set; }
 
         /// <summary>
         /// The base/root module the command is contained in.
         /// </summary>
         public Type RootCommandContainerType { get; set; }
 
         /// <summary>
         /// The direct group the command is contained in.
         /// </summary>
         public Type CommandContainerType { get; set; }
     }
 
     /// <summary>
     /// The command method.
     /// </summary>
     internal class CommandMethod
     {
         /// <summary>
         /// Gets or sets the command id.
         /// </summary>
         public ulong CommandId { get; set; }
 
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the method.
         /// </summary>
         public MethodInfo Method { get; set; }
     }
 
     /// <summary>
     /// The group command.
     /// </summary>
     internal class GroupCommand
     {
         /// <summary>
         /// Gets or sets the command id.
         /// </summary>
         public ulong CommandId { get; set; }
 
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the methods.
         /// </summary>
         public List<KeyValuePair<string, MethodInfo>> Methods { get; set; } = null;
     }
 
     /// <summary>
     /// The sub group command.
     /// </summary>
     internal class SubGroupCommand
     {
         /// <summary>
         /// Gets or sets the command id.
         /// </summary>
         public ulong CommandId { get; set; }
 
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the sub commands.
         /// </summary>
         public List<GroupCommand> SubCommands { get; set; } = new List<GroupCommand>();
     }
 
     /// <summary>
     /// The context menu command.
     /// </summary>
     internal class ContextMenuCommand
     {
         /// <summary>
         /// Gets or sets the command id.
         /// </summary>
         public ulong CommandId { get; set; }
 
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the method.
         /// </summary>
         public MethodInfo Method { get; set; }
     }
 }
diff --git a/DisCatSharp.ApplicationCommands/Context/InteractionContext.cs b/DisCatSharp.ApplicationCommands/Context/InteractionContext.cs
index 58b7a28b0..f81c21fd3 100644
--- a/DisCatSharp.ApplicationCommands/Context/InteractionContext.cs
+++ b/DisCatSharp.ApplicationCommands/Context/InteractionContext.cs
@@ -1,51 +1,56 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.ApplicationCommands
 {
     /// <summary>
     /// Represents a context for an interaction.
     /// </summary>
     public sealed class InteractionContext : BaseContext
     {
         /// <summary>
         /// Gets the users mentioned in the command parameters.
         /// </summary>
         public IReadOnlyList<DiscordUser> ResolvedUserMentions { get; internal set; }
 
         /// <summary>
         /// Gets the roles mentioned in the command parameters.
         /// </summary>
         public IReadOnlyList<DiscordRole> ResolvedRoleMentions { get; internal set; }
 
         /// <summary>
         /// Gets the channels mentioned in the command parameters.
         /// </summary>
         public IReadOnlyList<DiscordChannel> ResolvedChannelMentions { get; internal set; }
+
+        /// <summary>
+        /// Gets the attachments in the command parameters, if applicable.
+        /// </summary>
+        public IReadOnlyList<DiscordAttachment> Attachments { get; internal set; }
     }
 }
diff --git a/DisCatSharp/Clients/BaseDiscordClient.cs b/DisCatSharp/Clients/BaseDiscordClient.cs
index 98c9fa309..37bdf9ccc 100644
--- a/DisCatSharp/Clients/BaseDiscordClient.cs
+++ b/DisCatSharp/Clients/BaseDiscordClient.cs
@@ -1,304 +1,305 @@
 // 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.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Net;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
     /// <summary>
     /// Represents a common base for various Discord client implementations.
     /// </summary>
     public abstract class BaseDiscordClient : IDisposable
     {
         /// <summary>
         /// Gets the api client.
         /// </summary>
         internal protected DiscordApiClient ApiClient { get; }
+
         /// <summary>
         /// Gets the configuration.
         /// </summary>
         internal protected DiscordConfiguration Configuration { get; }
 
         /// <summary>
         /// Gets the instance of the logger for this client.
         /// </summary>
         public ILogger<BaseDiscordClient> Logger { get; }
 
         /// <summary>
         /// Gets the string representing the version of bot lib.
         /// </summary>
         public string VersionString { get; }
 
         /// <summary>
         /// Gets the bot library name.
         /// </summary>
         public string BotLibrary { get; }
 
         /// <summary>
         /// Gets the library team.
         /// </summary>
         public DisCatSharpTeam LibraryDeveloperTeam
             => this.ApiClient.GetDisCatSharpTeamAsync().Result;
 
         /// <summary>
         /// Gets the current user.
         /// </summary>
         public DiscordUser CurrentUser { get; internal set; }
 
         /// <summary>
         /// Gets the current application.
         /// </summary>
         public DiscordApplication CurrentApplication { get; internal set; }
 
         /// <summary>
         /// Gets the cached guilds for this client.
         /// </summary>
         public abstract IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 
         /// <summary>
         /// Gets the cached users for this client.
         /// </summary>
         protected internal ConcurrentDictionary<ulong, DiscordUser> UserCache { get; }
 
         /// <summary>
         /// <para>Gets the service provider.</para>
         /// <para>This allows passing data around without resorting to static members.</para>
         /// <para>Defaults to null.</para>
         /// </summary>
         internal IServiceProvider ServiceProvider { get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
         /// <summary>
         /// Gets the list of available voice regions. Note that this property will not contain VIP voice regions.
         /// </summary>
         public IReadOnlyDictionary<string, DiscordVoiceRegion> VoiceRegions
             => this._voice_regions_lazy.Value;
 
         /// <summary>
         /// Gets the list of available voice regions. This property is meant as a way to modify <see cref="VoiceRegions"/>.
         /// </summary>
         protected internal ConcurrentDictionary<string, DiscordVoiceRegion> InternalVoiceRegions { get; set; }
         internal Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> _voice_regions_lazy;
 
         /// <summary>
         /// Initializes this Discord API client.
         /// </summary>
         /// <param name="config">Configuration for this client.</param>
         protected BaseDiscordClient(DiscordConfiguration config)
         {
             this.Configuration = new DiscordConfiguration(config);
 
             if (this.Configuration.LoggerFactory == null)
             {
                 this.Configuration.LoggerFactory = new DefaultLoggerFactory();
                 this.Configuration.LoggerFactory.AddProvider(new DefaultLoggerProvider(this));
             }
             this.Logger = this.Configuration.LoggerFactory.CreateLogger<BaseDiscordClient>();
 
             this.ApiClient = new DiscordApiClient(this);
             this.UserCache = new ConcurrentDictionary<ulong, DiscordUser>();
             this.InternalVoiceRegions = new ConcurrentDictionary<string, DiscordVoiceRegion>();
             this._voice_regions_lazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(this.InternalVoiceRegions));
 
             var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
             var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
             if (iv != null)
             {
                 this.VersionString = iv.InformationalVersion;
             }
             else
             {
                 var v = a.GetName().Version;
                 var vs = v.ToString(3);
 
                 if (v.Revision > 0)
                     this.VersionString = $"{vs}, CI build {v.Revision}";
             }
 
             this.BotLibrary = "DisCatSharp";
 
             this.ServiceProvider = config.ServiceProvider;
         }
 
         /// <summary>
         /// Gets the current API application.
         /// </summary>
         /// <returns>Current API application.</returns>
         public async Task<DiscordApplication> GetCurrentApplicationAsync()
         {
             var tapp = await this.ApiClient.GetCurrentApplicationInfoAsync().ConfigureAwait(false);
             var app = new DiscordApplication
             {
                 Discord = this,
                 Id = tapp.Id,
                 Name = tapp.Name,
                 Description = tapp.Description,
                 Summary = tapp.Summary,
                 IconHash = tapp.IconHash,
                 RpcOrigins = tapp.RpcOrigins != null ? new ReadOnlyCollection<string>(tapp.RpcOrigins) : null,
                 Flags = tapp.Flags,
                 RequiresCodeGrant = tapp.BotRequiresCodeGrant,
                 IsPublic = tapp.IsPublicBot,
                 PrivacyPolicyUrl = tapp.PrivacyPolicyUrl,
                 TermsOfServiceUrl = tapp.TermsOfServiceUrl,
                 CustomInstallUrl = tapp.CustomInstallUrl,
                 InstallParams = tapp.InstallParams,
                 Tags = (tapp.Tags ?? Enumerable.Empty<string>()).ToArray()
             };
 
             // do team and owners
             // tbh fuck doing this properly
             if (tapp.Team == null)
             {
                 // singular owner
 
                 app.Owners = new ReadOnlyCollection<DiscordUser>(new[] { new DiscordUser(tapp.Owner) });
                 app.Team = null;
                 app.TeamName = null;
             }
             else
             {
                 // team owner
 
                 app.Team = new DiscordTeam(tapp.Team);
 
                 var members = tapp.Team.Members
                     .Select(x => new DiscordTeamMember(x) { Team = app.Team, User = new DiscordUser(x.User) })
                     .ToArray();
 
                 var owners = members
                     .Where(x => x.MembershipStatus == DiscordTeamMembershipStatus.Accepted)
                     .Select(x => x.User)
                     .ToArray();
 
                 app.Owners = new ReadOnlyCollection<DiscordUser>(owners);
                 app.Team.Owner = owners.FirstOrDefault(x => x.Id == tapp.Team.OwnerId);
                 app.Team.Members = new ReadOnlyCollection<DiscordTeamMember>(members);
                 app.TeamName = app.Team.Name;
             }
 
             app.GuildId = tapp.GuildId.HasValue ? tapp.GuildId.Value : null;
             app.Slug = tapp.Slug.HasValue ? tapp.Slug.Value : null;
             app.PrimarySkuId = tapp.PrimarySkuId.HasValue ? tapp.PrimarySkuId.Value : null;
             app.VerifyKey = tapp.VerifyKey.HasValue ? tapp.VerifyKey.Value : null;
             app.CoverImageHash = tapp.CoverImageHash.HasValue ? tapp.CoverImageHash.Value : null;
 
             return app;
         }
 
         /// <summary>
         /// Gets a list of regions
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
             => this.ApiClient.ListVoiceRegionsAsync();
 
         /// <summary>
         /// Initializes this client. This method fetches information about current user, application, and voice regions.
         /// </summary>
         /// <returns></returns>
         public virtual async Task InitializeAsync()
         {
             if (this.CurrentUser == null)
             {
                 this.CurrentUser = await this.ApiClient.GetCurrentUserAsync().ConfigureAwait(false);
                 this.UserCache.AddOrUpdate(this.CurrentUser.Id, this.CurrentUser, (id, xu) => this.CurrentUser);
             }
 
             if (this.Configuration.TokenType == TokenType.Bot && this.CurrentApplication == null)
                 this.CurrentApplication = await this.GetCurrentApplicationAsync().ConfigureAwait(false);
 
             if (this.Configuration.TokenType != TokenType.Bearer && this.InternalVoiceRegions.Count == 0)
             {
                 var vrs = await this.ListVoiceRegionsAsync().ConfigureAwait(false);
                 foreach (var xvr in vrs)
                     this.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
             }
         }
 
         /// <summary>
         /// Gets the current gateway info for the provided token.
         /// <para>If no value is provided, the configuration value will be used instead.</para>
         /// </summary>
         /// <returns>A gateway info object.</returns>
         public async Task<GatewayInfo> GetGatewayInfoAsync(string token = null)
         {
             if (this.Configuration.TokenType != TokenType.Bot)
                 throw new InvalidOperationException("Only bot tokens can access this info.");
 
             if (string.IsNullOrEmpty(this.Configuration.Token))
             {
                 if (string.IsNullOrEmpty(token))
                     throw new InvalidOperationException("Could not locate a valid token.");
 
                 this.Configuration.Token = token;
 
                 var res = await this.ApiClient.GetGatewayInfoAsync().ConfigureAwait(false);
                 this.Configuration.Token = null;
                 return res;
             }
 
             return await this.ApiClient.GetGatewayInfoAsync().ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets a cached user.
         /// </summary>
         /// <param name="user_id">The user_id.</param>
         internal DiscordUser GetCachedOrEmptyUserInternal(ulong user_id)
         {
             this.TryGetCachedUserInternal(user_id, out var user);
             return user;
         }
 
         /// <summary>
         /// Tries the get a cached user.
         /// </summary>
         /// <param name="user_id">The user_id.</param>
         /// <param name="user">The user.</param>
         internal bool TryGetCachedUserInternal(ulong user_id, out DiscordUser user)
         {
             if (this.UserCache.TryGetValue(user_id, out user))
                 return true;
 
             user = new DiscordUser { Id = user_id, Discord = this };
             return false;
         }
 
         /// <summary>
         /// Disposes this client.
         /// </summary>
         public abstract void Dispose();
     }
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordInteraction.cs b/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
index 4aa4c14ae..46114490f 100644
--- a/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
@@ -1,181 +1,206 @@
 // 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.Threading.Tasks;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents an interaction that was invoked.
     /// </summary>
     public sealed class DiscordInteraction : SnowflakeObject
     {
         /// <summary>
         /// Gets the type of interaction invoked.
         /// </summary>
         [JsonProperty("type")]
         public InteractionType Type { get; internal set; }
 
         /// <summary>
         /// Gets the command data for this interaction.
         /// </summary>
         [JsonProperty("data", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordInteractionData Data { get; internal set; }
 
         /// <summary>
         /// Gets the Id of the guild that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public ulong? GuildId { get; internal set; }
 
         /// <summary>
         /// Gets the guild that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public DiscordGuild Guild
             => (this.Discord as DiscordClient).InternalGetCachedGuild(this.GuildId);
 
         /// <summary>
         /// Gets the Id of the channel that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public ulong ChannelId { get; internal set; }
 
         /// <summary>
         /// Gets the channel that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel Channel
              => (this.Discord as DiscordClient).InternalGetCachedChannel(this.ChannelId) ?? (DiscordChannel)(this.Discord as DiscordClient).InternalGetCachedThread(this.ChannelId) ?? (this.Guild == null ? new DiscordDmChannel { Id = this.ChannelId, Type = ChannelType.Private, Discord = this.Discord } : null);
 
         /// <summary>
         /// Gets the user that invoked this interaction.
         /// <para>This can be cast to a <see cref="DisCatSharp.Entities.DiscordMember"/> if created in a guild.</para>
         /// </summary>
         [JsonIgnore]
         public DiscordUser User { get; internal set; }
 
         /// <summary>
         /// Gets the continuation token for responding to this interaction.
         /// </summary>
         [JsonProperty("token")]
         public string Token { get; internal set; }
 
         /// <summary>
         /// Gets the version number for this interaction type.
         /// </summary>
         [JsonProperty("version")]
         public int Version { get; internal set; }
 
         /// <summary>
         /// Gets the ID of the application that created this interaction.
         /// </summary>
         [JsonProperty("application_id")]
         public ulong ApplicationId { get; internal set; }
 
         /// <summary>
         /// The message this interaction was created with, if any.
         /// </summary>
         [JsonProperty("message")]
         internal DiscordMessage Message { get; set; }
 
         /// <summary>
         /// Creates a response to this interaction.
         /// </summary>
         /// <param name="type">The type of the response.</param>
         /// <param name="builder">The data, if any, to send.</param>
         public Task CreateResponseAsync(InteractionResponseType type, DiscordInteractionResponseBuilder builder = null) =>
             this.Discord.ApiClient.CreateInteractionResponseAsync(this.Id, this.Token, type, builder);
 
         /// <summary>
         /// Creates a modal response to this interaction.
         /// </summary>
         /// <param name="builder">The data to send.</param>
         public Task CreateInteractionModalResponseAsync(DiscordInteractionModalBuilder builder) =>
             this.Discord.ApiClient.CreateInteractionModalResponseAsync(this.Id, this.Token, InteractionResponseType.Modal, builder);
 
         /// <summary>
         /// Gets the original interaction response.
         /// </summary>
         /// <returns>The origingal message that was sent. This <b>does not work on ephemeral messages.</b></returns>
         public Task<DiscordMessage> GetOriginalResponseAsync() =>
             this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
 
         /// <summary>
         /// Edits the original interaction response.
         /// </summary>
         /// <param name="builder">The webhook builder.</param>
         /// <returns>The edited <see cref="DiscordMessage"/>.</returns>
         public async Task<DiscordMessage> EditOriginalResponseAsync(DiscordWebhookBuilder builder)
         {
             builder.Validate(isInteractionResponse: true);
+            if (builder._keepAttachments.HasValue && builder._keepAttachments.Value)
+            {
+                var attachments = this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token).Result.Attachments;
+                if (attachments?.Count > 0)
+                {
+                    builder._attachments.AddRange(attachments);
+                }
+            }
+            else if (builder._keepAttachments.HasValue)
+            {
+                builder._attachments.Clear();
+            }
 
             return await this.Discord.ApiClient.EditOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token, builder).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes the original interaction response.
         /// </summary>>
         public Task DeleteOriginalResponseAsync() =>
             this.Discord.ApiClient.DeleteOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
 
         /// <summary>
         /// Creates a follow up message to this interaction.
         /// </summary>
         /// <param name="builder">The webhook builder.</param>
         /// <returns>The created <see cref="DiscordMessage"/>.</returns>
         public async Task<DiscordMessage> CreateFollowupMessageAsync(DiscordFollowupMessageBuilder builder)
         {
             builder.Validate();
 
             return await this.Discord.ApiClient.CreateFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, builder).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets a follow up message.
         /// </summary>
         /// <param name="messageId">The id of the follow up message.</param>
         public Task<DiscordMessage> GetFollowupMessageAsync(ulong messageId) =>
             this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
 
         /// <summary>
         /// Edits a follow up message.
         /// </summary>
         /// <param name="messageId">The id of the follow up message.</param>
         /// <param name="builder">The webhook builder.</param>
         /// <returns>The edited <see cref="DiscordMessage"/>.</returns>
         public async Task<DiscordMessage> EditFollowupMessageAsync(ulong messageId, DiscordWebhookBuilder builder)
         {
             builder.Validate(isFollowup: true);
 
+            if (builder._keepAttachments.HasValue && builder._keepAttachments.Value)
+            {
+                var attachments = this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId).Result.Attachments;
+                if (attachments?.Count > 0)
+                {
+                    builder._attachments.AddRange(attachments);
+                }
+            }
+            else if (builder._keepAttachments.HasValue)
+            {
+                builder._attachments.Clear();
+            }
+
             return await this.Discord.ApiClient.EditFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId, builder).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a follow up message.
         /// </summary>
         /// <param name="messageId">The id of the follow up message.</param>
         public Task DeleteFollowupMessageAsync(ulong messageId) =>
             this.Discord.ApiClient.DeleteFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
     }
 }
diff --git a/DisCatSharp/Entities/Message/DiscordAttachment.cs b/DisCatSharp/Entities/Message/DiscordAttachment.cs
index bba2ed59f..e2ca776f5 100644
--- a/DisCatSharp/Entities/Message/DiscordAttachment.cs
+++ b/DisCatSharp/Entities/Message/DiscordAttachment.cs
@@ -1,93 +1,93 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents an attachment for a message.
     /// </summary>
     public class DiscordAttachment : SnowflakeObject
     {
         /// <summary>
         /// Gets the name of the file.
         /// </summary>
         [JsonProperty("filename", NullValueHandling = NullValueHandling.Ignore)]
         public string FileName { get; internal set; }
 
         /// <summary>
         /// Gets the description of the file.
         /// </summary>
         [JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
-        public string Description { get; internal set; }
+        public string Description { get; set; }
 
         /// <summary>
         /// Gets the media, or MIME, type of the file.
         /// </summary>
         [JsonProperty("content_type", NullValueHandling = NullValueHandling.Ignore)]
         public string MediaType { get; internal set; }
 
         /// <summary>
         /// Gets the file size in bytes.
         /// </summary>
         [JsonProperty("size", NullValueHandling = NullValueHandling.Ignore)]
         public int? FileSize { get; internal set; }
 
         /// <summary>
         /// Gets the URL of the file.
         /// </summary>
         [JsonProperty("url", NullValueHandling = NullValueHandling.Ignore)]
         public string Url { get; internal set; }
 
         /// <summary>
         /// Gets the proxied URL of the file.
         /// </summary>
         [JsonProperty("proxy_url", NullValueHandling = NullValueHandling.Ignore)]
         public string ProxyUrl { get; internal set; }
 
         /// <summary>
         /// Gets the height. Applicable only if the attachment is an image.
         /// </summary>
         [JsonProperty("height", NullValueHandling = NullValueHandling.Ignore)]
         public int? Height { get; internal set; }
 
         /// <summary>
         /// Gets the width. Applicable only if the attachment is an image.
         /// </summary>
         [JsonProperty("width", NullValueHandling = NullValueHandling.Ignore)]
         public int? Width { get; internal set; }
 
         /// <summary>
         /// Gets whether this attachment is ephemeral.
         /// Ephemeral attachments will automatically be removed after a set period of time.
         /// Ephemeral attachments on messages are guaranteed to be available as long as the message itself exists.
         /// </summary>
         [JsonProperty("ephemeral", NullValueHandling = NullValueHandling.Ignore)]
         public bool? Ephemeral { get; internal set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordAttachment"/> class.
         /// </summary>
         internal DiscordAttachment() { }
     }
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessage.cs b/DisCatSharp/Entities/Message/DiscordMessage.cs
index 5ecddffaa..6e124e012 100644
--- a/DisCatSharp/Entities/Message/DiscordMessage.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessage.cs
@@ -1,881 +1,888 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a Discord text message.
     /// </summary>
     public class DiscordMessage : SnowflakeObject, IEquatable<DiscordMessage>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMessage"/> class.
         /// </summary>
         internal DiscordMessage()
         {
             this._attachmentsLazy = new Lazy<IReadOnlyList<DiscordAttachment>>(() => new ReadOnlyCollection<DiscordAttachment>(this._attachments));
             this._embedsLazy = new Lazy<IReadOnlyList<DiscordEmbed>>(() => new ReadOnlyCollection<DiscordEmbed>(this._embeds));
             this._mentionedChannelsLazy = new Lazy<IReadOnlyList<DiscordChannel>>(() => this._mentionedChannels != null
                     ? new ReadOnlyCollection<DiscordChannel>(this._mentionedChannels)
                     : Array.Empty<DiscordChannel>());
             this._mentionedRolesLazy = new Lazy<IReadOnlyList<DiscordRole>>(() => this._mentionedRoles != null ? new ReadOnlyCollection<DiscordRole>(this._mentionedRoles) : Array.Empty<DiscordRole>());
             this._mentionedUsersLazy = new Lazy<IReadOnlyList<DiscordUser>>(() => new ReadOnlyCollection<DiscordUser>(this._mentionedUsers));
             this._reactionsLazy = new Lazy<IReadOnlyList<DiscordReaction>>(() => new ReadOnlyCollection<DiscordReaction>(this._reactions));
             this._stickersLazy = new Lazy<IReadOnlyList<DiscordSticker>>(() => new ReadOnlyCollection<DiscordSticker>(this._stickers));
             this._jumpLink = new Lazy<Uri>(() =>
             {
                 var gid = this.Channel != null
                     ? this.Channel is DiscordDmChannel ? "@me" : this.Channel.GuildId.Value.ToString(CultureInfo.InvariantCulture)
                     : this.InternalThread.GuildId.Value.ToString(CultureInfo.InvariantCulture);
                 var cid = this.ChannelId.ToString(CultureInfo.InvariantCulture);
                 var mid = this.Id.ToString(CultureInfo.InvariantCulture);
 
                 return new Uri($"https://{(this.Discord.Configuration.UseCanary ? "canary.discord.com" : "discord.com")}/channels/{gid}/{cid}/{mid}");
             });
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMessage"/> class.
         /// </summary>
         /// <param name="other">The other.</param>
         internal DiscordMessage(DiscordMessage other)
             : this()
         {
             this.Discord = other.Discord;
 
             this._attachments = other._attachments; // the attachments cannot change, thus no need to copy and reallocate.
             this._embeds = new List<DiscordEmbed>(other._embeds);
 
             if (other._mentionedChannels != null)
                 this._mentionedChannels = new List<DiscordChannel>(other._mentionedChannels);
             if (other._mentionedRoles != null)
                 this._mentionedRoles = new List<DiscordRole>(other._mentionedRoles);
             if (other._mentionedRoleIds != null)
                 this._mentionedRoleIds = new List<ulong>(other._mentionedRoleIds);
             this._mentionedUsers = new List<DiscordUser>(other._mentionedUsers);
             this._reactions = new List<DiscordReaction>(other._reactions);
             this._stickers = new List<DiscordSticker>(other._stickers);
 
             this.Author = other.Author;
             this.ChannelId = other.ChannelId;
             this.Content = other.Content;
             this.EditedTimestampRaw = other.EditedTimestampRaw;
             this.Id = other.Id;
             this.IsTTS = other.IsTTS;
             this.MessageType = other.MessageType;
             this.Pinned = other.Pinned;
             this.TimestampRaw = other.TimestampRaw;
             this.WebhookId = other.WebhookId;
         }
 
         /// <summary>
         /// Gets the channel in which the message was sent.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel Channel
         {
             get => (this.Discord as DiscordClient)?.InternalGetCachedChannel(this.ChannelId) ?? this._channel;
             internal set => this._channel = value;
         }
 
         private DiscordChannel _channel;
 
         /// <summary>
         /// Gets the thread in which the message was sent.
         /// </summary>
         [JsonIgnore]
         private DiscordThreadChannel InternalThread
         {
             get => (this.Discord as DiscordClient)?.InternalGetCachedThread(this.ChannelId) ?? this._thread;
             set => this._thread = value;
         }
 
         private DiscordThreadChannel _thread;
 
         /// <summary>
         /// Gets the ID of the channel in which the message was sent.
         /// </summary>
         [JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong ChannelId { get; internal set; }
 
 
         /// <summary>
         /// Gets the components this message was sent with.
         /// </summary>
         [JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
         public IReadOnlyCollection<DiscordActionRowComponent> Components { get; internal set; }
 
         /// <summary>
         /// Gets the user or member that sent the message.
         /// </summary>
         [JsonProperty("author", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordUser Author { get; internal set; }
 
         /// <summary>
         /// Gets the message's content.
         /// </summary>
         [JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
         public string Content { get; internal set; }
 
         /// <summary>
         /// Gets the message's creation timestamp.
         /// </summary>
         [JsonIgnore]
         public DateTimeOffset Timestamp
             => !string.IsNullOrWhiteSpace(this.TimestampRaw) && DateTimeOffset.TryParse(this.TimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
                 dto : this.CreationTimestamp;
 
         /// <summary>
         /// Gets the message's creation timestamp as raw string.
         /// </summary>
         [JsonProperty("timestamp", NullValueHandling = NullValueHandling.Ignore)]
         internal string TimestampRaw { get; set; }
 
         /// <summary>
         /// Gets the message's edit timestamp. Will be null if the message was not edited.
         /// </summary>
         [JsonIgnore]
         public DateTimeOffset? EditedTimestamp
             => !string.IsNullOrWhiteSpace(this.EditedTimestampRaw) && DateTimeOffset.TryParse(this.EditedTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
                 (DateTimeOffset?)dto : null;
 
         /// <summary>
         /// Gets the message's edit timestamp as raw string. Will be null if the message was not edited.
         /// </summary>
         [JsonProperty("edited_timestamp", NullValueHandling = NullValueHandling.Ignore)]
         internal string EditedTimestampRaw { get; set; }
 
         /// <summary>
         /// Gets whether this message was edited.
         /// </summary>
         [JsonIgnore]
         public bool IsEdited
             => !string.IsNullOrWhiteSpace(this.EditedTimestampRaw);
 
         /// <summary>
         /// Gets whether the message is a text-to-speech message.
         /// </summary>
         [JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsTTS { get; internal set; }
 
         /// <summary>
         /// Gets whether the message mentions everyone.
         /// </summary>
         [JsonProperty("mention_everyone", NullValueHandling = NullValueHandling.Ignore)]
         public bool MentionEveryone { get; internal set; }
 
         /// <summary>
         /// Gets users or members mentioned by this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordUser> MentionedUsers
             => this._mentionedUsersLazy.Value;
 
         [JsonProperty("mentions", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordUser> _mentionedUsers;
         [JsonIgnore]
         internal readonly Lazy<IReadOnlyList<DiscordUser>> _mentionedUsersLazy;
 
         // TODO this will probably throw an exception in DMs since it tries to wrap around a null List...
         // this is probably low priority but need to find out a clean way to solve it...
         /// <summary>
         /// Gets roles mentioned by this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordRole> MentionedRoles
             => this._mentionedRolesLazy.Value;
 
         [JsonIgnore]
         internal List<DiscordRole> _mentionedRoles;
 
         [JsonProperty("mention_roles")]
         internal List<ulong> _mentionedRoleIds;
 
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordRole>> _mentionedRolesLazy;
 
         /// <summary>
         /// Gets channels mentioned by this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordChannel> MentionedChannels
             => this._mentionedChannelsLazy.Value;
 
         [JsonIgnore]
         internal List<DiscordChannel> _mentionedChannels;
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordChannel>> _mentionedChannelsLazy;
 
         /// <summary>
         /// Gets files attached to this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordAttachment> Attachments
             => this._attachmentsLazy.Value;
 
         [JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordAttachment> _attachments = new();
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordAttachment>> _attachmentsLazy;
 
         /// <summary>
         /// Gets embeds attached to this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordEmbed> Embeds
             => this._embedsLazy.Value;
 
         [JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordEmbed> _embeds = new();
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordEmbed>> _embedsLazy;
 
         /// <summary>
         /// Gets reactions used on this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordReaction> Reactions
             => this._reactionsLazy.Value;
 
         [JsonProperty("reactions", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordReaction> _reactions = new();
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordReaction>> _reactionsLazy;
 
         /*
         /// <summary>
         /// Gets the nonce sent with the message, if the message was sent by the client.
         /// </summary>
         [JsonProperty("nonce", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? Nonce { get; internal set; }
         */
 
         /// <summary>
         /// Gets whether the message is pinned.
         /// </summary>
         [JsonProperty("pinned", NullValueHandling = NullValueHandling.Ignore)]
         public bool Pinned { get; internal set; }
 
         /// <summary>
         /// Gets the id of the webhook that generated this message.
         /// </summary>
         [JsonProperty("webhook_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? WebhookId { get; internal set; }
 
         /// <summary>
         /// Gets the type of the message.
         /// </summary>
         [JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
         public MessageType? MessageType { get; internal set; }
 
         /// <summary>
         /// Gets the message activity in the Rich Presence embed.
         /// </summary>
         [JsonProperty("activity", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordMessageActivity Activity { get; internal set; }
 
         /// <summary>
         /// Gets the message application in the Rich Presence embed.
         /// </summary>
         [JsonProperty("application", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordMessageApplication Application { get; internal set; }
 
         /// <summary>
         /// Gets the message application id in the Rich Presence embed.
         /// </summary>
         [JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong ApplicationId { get; internal set; }
 
 
         /// <summary>
         /// Gets the internal reference.
         /// </summary>
         [JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
         internal InternalDiscordMessageReference? InternalReference { get; set; }
 
         /// <summary>
         /// Gets the original message reference from the crossposted message.
         /// </summary>
         [JsonIgnore]
         public DiscordMessageReference Reference
             => this.InternalReference.HasValue ? this?.InternalBuildMessageReference() : null;
 
         /// <summary>
         /// Gets the bitwise flags for this message.
         /// </summary>
         [JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
         public MessageFlags? Flags { get; internal set; }
 
         /// <summary>
         /// Gets whether the message originated from a webhook.
         /// </summary>
         [JsonIgnore]
         public bool WebhookMessage
             => this.WebhookId != null;
 
         /// <summary>
         /// Gets the jump link to this message.
         /// </summary>
         [JsonIgnore]
         public Uri JumpLink => this._jumpLink.Value;
         private readonly Lazy<Uri> _jumpLink;
 
         /// <summary>
         /// Gets stickers for this message.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordSticker> Stickers
             => this._stickersLazy.Value;
 
         [JsonProperty("sticker_items", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordSticker> _stickers = new();
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordSticker>> _stickersLazy;
 
         /// <summary>
         /// Gets the guild id.
         /// </summary>
         [JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
         internal ulong? GuildId { get; set; }
 
         /// <summary>
         /// Gets the message object for the referenced message
         /// </summary>
         [JsonProperty("referenced_message", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordMessage ReferencedMessage { get; internal set; }
 
         /// <summary>
         /// Gets whether the message is a response to an interaction.
         /// </summary>
         [JsonProperty("interaction", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordMessageInteraction Interaction { get; internal set; }
 
         /// <summary>
         /// Gets the thread that was started from this message.
         /// </summary>
         [JsonProperty("thread", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordThreadChannel Thread { get; internal set; }
 
         /// <summary>
         /// Build the message reference.
         /// </summary>
         internal DiscordMessageReference InternalBuildMessageReference()
         {
             var client = this.Discord as DiscordClient;
             var guildId = this.InternalReference.Value.GuildId;
             var channelId = this.InternalReference.Value.ChannelId;
             var messageId = this.InternalReference.Value.MessageId;
 
             var reference = new DiscordMessageReference();
 
             if (guildId.HasValue)
                 reference.Guild = client._guilds.TryGetValue(guildId.Value, out var g)
                     ? g
                     : new DiscordGuild
                 {
                     Id = guildId.Value,
                     Discord = client
                 };
 
             var channel = client.InternalGetCachedChannel(channelId.Value);
 
             if (channel == null)
             {
                 reference.Channel = new DiscordChannel
                 {
                     Id = channelId.Value,
                     Discord = client
                 };
 
                 if (guildId.HasValue)
                     reference.Channel.GuildId = guildId.Value;
             }
 
             else reference.Channel = channel;
 
             if (client.MessageCache != null && client.MessageCache.TryGet(m => m.Id == messageId.Value && m.ChannelId == channelId, out var msg))
                 reference.Message = msg;
 
             else
             {
                 reference.Message = new DiscordMessage
                 {
                     ChannelId = this.ChannelId,
                     Discord = client
                 };
 
                 if (messageId.HasValue)
                     reference.Message.Id = messageId.Value;
             }
 
             return reference;
         }
 
 
         /// <summary>
         /// Gets the mentions.
         /// </summary>
         /// <returns>An array of IMentions.</returns>
         private IMention[] GetMentions()
         {
             var mentions = new List<IMention>();
 
             if (this.ReferencedMessage != null && this._mentionedUsers.Contains(this.ReferencedMessage.Author))
                 mentions.Add(new RepliedUserMention()); // Return null to allow all mentions
 
             if (this._mentionedUsers.Any())
                 mentions.AddRange(this._mentionedUsers.Select(m => (IMention)new UserMention(m)));
 
             if (this._mentionedRoleIds.Any())
                 mentions.AddRange(this._mentionedRoleIds.Select(r => (IMention)new RoleMention(r)));
 
             return mentions.ToArray();
         }
 
         /// <summary>
         /// Populates the mentions.
         /// </summary>
         internal void PopulateMentions()
         {
             var guild = this.Channel?.Guild;
             this._mentionedUsers ??= new List<DiscordUser>();
             this._mentionedRoles ??= new List<DiscordRole>();
             this._mentionedChannels ??= new List<DiscordChannel>();
 
             var mentionedUsers = new HashSet<DiscordUser>(new DiscordUserComparer());
             if (guild != null)
             {
                 foreach (var usr in this._mentionedUsers)
                 {
                     usr.Discord = this.Discord;
                     this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
                     {
                         old.Username = usr.Username;
                         old.Discriminator = usr.Discriminator;
                         old.AvatarHash = usr.AvatarHash;
                         return old;
                     });
 
                     mentionedUsers.Add(guild._members.TryGetValue(usr.Id, out var member) ? member : usr);
                 }
             }
             if (!string.IsNullOrWhiteSpace(this.Content))
             {
                 //mentionedUsers.UnionWith(Utilities.GetUserMentions(this).Select(this.Discord.GetCachedOrEmptyUserInternal));
                 if (guild != null)
                 {
                     //this._mentionedRoles = this._mentionedRoles.Union(Utilities.GetRoleMentions(this).Select(xid => guild.GetRole(xid))).ToList();
                     this._mentionedRoles = this._mentionedRoles.Union(this._mentionedRoleIds.Select(xid => guild.GetRole(xid))).ToList();
                     this._mentionedChannels = this._mentionedChannels.Union(Utilities.GetChannelMentions(this).Select(xid => guild.GetChannel(xid))).ToList();
                 }
             }
 
             this._mentionedUsers = mentionedUsers.ToList();
         }
 
         /// <summary>
         /// Edits the message.
         /// </summary>
         /// <param name="content">New content.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> ModifyAsync(Optional<string> content)
-            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>());
+            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
         /// <summary>
         /// Edits the message.
         /// </summary>
         /// <param name="embed">New embed.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> ModifyAsync(Optional<DiscordEmbed> embed = default)
-            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, embed.HasValue ? new[] {embed.Value} : Array.Empty<DiscordEmbed>(), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>());
+            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, embed.HasValue ? new[] {embed.Value} : Array.Empty<DiscordEmbed>(), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
         /// <summary>
         /// Edits the message.
         /// </summary>
         /// <param name="content">New content.</param>
         /// <param name="embed">New embed.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<DiscordEmbed> embed = default)
-            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embed.HasValue ? new[] {embed.Value} : Array.Empty<DiscordEmbed>(), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>());
+            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embed.HasValue ? new[] {embed.Value} : Array.Empty<DiscordEmbed>(), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
         /// <summary>
         /// Edits the message.
         /// </summary>
         /// <param name="content">New content.</param>
         /// <param name="embeds">New embeds.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds = default)
-            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>());
+            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
         /// <summary>
         /// Edits the message.
         /// </summary>
         /// <param name="builder">The builder of the message to edit.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> ModifyAsync(DiscordMessageBuilder builder)
         {
             builder.Validate(true);
-            return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, new Optional<IEnumerable<DiscordEmbed>>(builder.Embeds), builder.Mentions, builder.Components, builder.Suppressed, builder.Files).ConfigureAwait(false);
+            return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, new Optional<IEnumerable<DiscordEmbed>>(builder.Embeds), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? new Optional<IEnumerable<DiscordAttachment>>(builder.Attachments) : builder._keepAttachments.HasValue ? builder._keepAttachments.Value ? new Optional<IEnumerable<DiscordAttachment>>(this.Attachments) : Array.Empty<DiscordAttachment>() : null);
         }
 
         /// <summary>
         /// Edits the message embed suppression.
         /// </summary>
         /// <param name="suppress">Suppress embeds.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> ModifySuppressionAsync(bool suppress = false)
-            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, suppress, default);
+            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, suppress, default, default);
+
+        /// <summary>
+        /// Clears all attachments from the message.
+        /// </summary>
+        /// <returns></returns>
+        public Task<DiscordMessage> ClearAttachmentsAsync()
+            => this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, default, default, Array.Empty<DiscordAttachment>());
 
         /// <summary>
         /// Edits the message.
         /// </summary>
         /// <param name="action">The builder of the message to edit.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> ModifyAsync(Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
             builder.Validate(true);
-            return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, new Optional<IEnumerable<DiscordEmbed>>(builder.Embeds), builder.Mentions, builder.Components, builder.Suppressed, builder.Files).ConfigureAwait(false);
+            return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, new Optional<IEnumerable<DiscordEmbed>>(builder.Embeds), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? new Optional<IEnumerable<DiscordAttachment>>(builder.Attachments) : builder._keepAttachments.HasValue ? builder._keepAttachments.Value ? new Optional<IEnumerable<DiscordAttachment>>(this.Attachments) : Array.Empty<DiscordAttachment>() : null);
         }
 
         /// <summary>
         /// Deletes the message.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAsync(string reason = null)
             => this.Discord.ApiClient.DeleteMessageAsync(this.ChannelId, this.Id, reason);
 
         /// <summary>
         /// Creates a thread.
         /// Depending on the <see cref="ChannelType"/> of the parent channel it's either a <see cref="ChannelType.PublicThread"/> or a <see cref="ChannelType.NewsThread"/>.
         /// </summary>
         /// <param name="name">The name of the thread.</param>
         /// <param name="auto_archive_duration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/></param>
         /// <param name="rate_limit_per_user">The per user ratelimit, aka slowdown.</param>
         /// <param name="reason">The reason.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified.</exception>
         public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration auto_archive_duration = ThreadAutoArchiveDuration.OneHour, int? rate_limit_per_user = null, string reason = null)
         {
             return Utilities.CheckThreadAutoArchiveDurationFeature(this.Channel.Guild, auto_archive_duration)
                     ? await this.Discord.ApiClient.CreateThreadWithMessageAsync(this.ChannelId, this.Id, name, auto_archive_duration, rate_limit_per_user, reason)
                     : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(auto_archive_duration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
         }
 
         /// <summary>
         /// Pins the message in its channel.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task PinAsync()
             => this.Discord.ApiClient.PinMessageAsync(this.ChannelId, this.Id);
 
         /// <summary>
         /// Unpins the message in its channel.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnpinAsync()
             => this.Discord.ApiClient.UnpinMessageAsync(this.ChannelId, this.Id);
 
         /// <summary>
         /// Responds to the message. This produces a reply.
         /// </summary>
         /// <param name="content">Message content to respond with.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> RespondAsync(string content)
             => this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
         /// <summary>
         /// Responds to the message. This produces a reply.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
             => this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
         /// <summary>
         /// Responds to the message. This produces a reply.
         /// </summary>
         /// <param name="content">Message content to respond with.</param>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
             => this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
         /// <summary>
         /// Responds to the message. This produces a reply.
         /// </summary>
         /// <param name="builder">The Discord message builder.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
             => this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 
         /// <summary>
         /// Responds to the message. This produces a reply.
         /// </summary>
         /// <param name="action">The Discord message builder.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
             return this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
         }
 
         /// <summary>
         /// Creates a reaction to this message.
         /// </summary>
         /// <param name="emoji">The emoji you want to react with, either an emoji or name:id</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task CreateReactionAsync(DiscordEmoji emoji)
             => this.Discord.ApiClient.CreateReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
         /// <summary>
         /// Deletes your own reaction
         /// </summary>
         /// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteOwnReactionAsync(DiscordEmoji emoji)
             => this.Discord.ApiClient.DeleteOwnReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
         /// <summary>
         /// Deletes another user's reaction.
         /// </summary>
         /// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id.</param>
         /// <param name="user">Member you want to remove the reaction for</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteReactionAsync(DiscordEmoji emoji, DiscordUser user, string reason = null)
             => this.Discord.ApiClient.DeleteUserReactionAsync(this.ChannelId, this.Id, user.Id, emoji.ToReactionString(), reason);
 
         /// <summary>
         /// Gets users that reacted with this emoji.
         /// </summary>
         /// <param name="emoji">Emoji to react with.</param>
         /// <param name="limit">Limit of users to fetch.</param>
         /// <param name="after">Fetch users after this user's id.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
             => this.GetReactionsInternalAsync(emoji, limit, after);
 
         /// <summary>
         /// Deletes all reactions for this message.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAllReactionsAsync(string reason = null)
             => this.Discord.ApiClient.DeleteAllReactionsAsync(this.ChannelId, this.Id, reason);
 
         /// <summary>
         /// Deletes all reactions of a specific reaction for this message.
         /// </summary>
         /// <param name="emoji">The emoji to clear, either an emoji or name:id.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteReactionsEmojiAsync(DiscordEmoji emoji)
             => this.Discord.ApiClient.DeleteReactionsEmojiAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
         /// <summary>
         /// Gets the reactions.
         /// </summary>
         /// <param name="emoji">The emoji to search for.</param>
         /// <param name="limit">The limit of results.</param>
         /// <param name="after">Get the reasctions after snowflake.</param>
         private async Task<IReadOnlyList<DiscordUser>> GetReactionsInternalAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
         {
             if (limit < 0)
                 throw new ArgumentException("Cannot get a negative number of reactions' users.");
 
             if (limit == 0)
                 return Array.Empty<DiscordUser>();
 
             var users = new List<DiscordUser>(limit);
             var remaining = limit;
             var last = after;
 
             int lastCount;
             do
             {
                 var fetchSize = remaining > 100 ? 100 : remaining;
                 var fetch = await this.Discord.ApiClient.GetReactionsAsync(this.Channel.Id, this.Id, emoji.ToReactionString(), last, fetchSize).ConfigureAwait(false);
 
                 lastCount = fetch.Count;
                 remaining -= lastCount;
 
                 users.AddRange(fetch);
                 last = fetch.LastOrDefault()?.Id;
             } while (remaining > 0 && lastCount > 0);
 
             return new ReadOnlyCollection<DiscordUser>(users);
         }
 
         /// <summary>
         /// Returns a string representation of this message.
         /// </summary>
         /// <returns>String representation of this message.</returns>
         public override string ToString() => $"Message {this.Id}; Attachment count: {this._attachments.Count}; Embed count: {this._embeds.Count}; Contents: {this.Content}";
 
         /// <summary>
         /// Checks whether this <see cref="DiscordMessage"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordMessage"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordMessage);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordMessage"/> is equal to another <see cref="DiscordMessage"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordMessage"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordMessage"/> is equal to this <see cref="DiscordMessage"/>.</returns>
         public bool Equals(DiscordMessage e) => e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.ChannelId == e.ChannelId));
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordMessage"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordMessage"/>.</returns>
         public override int GetHashCode()
         {
             var hash = 13;
 
             hash = (hash * 7) + this.Id.GetHashCode();
             hash = (hash * 7) + this.ChannelId.GetHashCode();
 
             return hash;
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordMessage"/> objects are equal.
         /// </summary>
         /// <param name="e1">First message to compare.</param>
         /// <param name="e2">Second message to compare.</param>
         /// <returns>Whether the two messages are equal.</returns>
         public static bool operator ==(DiscordMessage e1, DiscordMessage e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.ChannelId == e2.ChannelId));
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordMessage"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First message to compare.</param>
         /// <param name="e2">Second message to compare.</param>
         /// <returns>Whether the two messages are not equal.</returns>
         public static bool operator !=(DiscordMessage e1, DiscordMessage e2)
             => !(e1 == e2);
     }
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
index 1b382a1fe..95242597a 100644
--- a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
@@ -1,432 +1,460 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Constructs a Message to be sent.
     /// </summary>
     public sealed class DiscordMessageBuilder
     {
         /// <summary>
         /// Gets or Sets the Message to be sent.
         /// </summary>
         public string Content
         {
             get => this._content;
             set
             {
                 if (value != null && value.Length > 2000)
                     throw new ArgumentException("Content cannot exceed 2000 characters.", nameof(value));
                 this._content = value;
             }
         }
         private string _content;
 
         /// <summary>
         /// Gets or sets the embed for the builder. This will always set the builder to have one embed.
         /// </summary>
         public DiscordEmbed Embed
         {
             get => this._embeds.Count > 0 ? this._embeds[0] : null;
             set
             {
                 this._embeds.Clear();
                 this._embeds.Add(value);
             }
         }
 
         /// <summary>
         /// Gets the Sticker to be send.
         /// </summary>
         public DiscordSticker Sticker { get; set; }
 
         /// <summary>
         /// Gets the Embeds to be sent.
         /// </summary>
         public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
         private readonly List<DiscordEmbed> _embeds = new();
 
         /// <summary>
         /// Gets or Sets if the message should be TTS.
         /// </summary>
         public bool IsTTS { get; set; } = false;
 
+        /// <summary>
+        /// Whether to keep previous attachments.
+        /// </summary>
+        internal bool? _keepAttachments = null;
+
         /// <summary>
         /// Gets the Allowed Mentions for the message to be sent.
         /// </summary>
         public List<IMention> Mentions { get; private set; } = null;
 
         /// <summary>
         /// Gets the Files to be sent in the Message.
         /// </summary>
         public IReadOnlyCollection<DiscordMessageFile> Files => this._files;
         internal readonly List<DiscordMessageFile> _files = new();
 
         /// <summary>
         /// Gets the components that will be attached to the message.
         /// </summary>
         public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
         internal readonly List<DiscordActionRowComponent> _components = new(5);
 
         /// <summary>
         /// Gets the Attachments to be sent in the Message.
         /// </summary>
-        internal List<DiscordAttachment> Attachments { get; private set; } = null;
+        public IReadOnlyList<DiscordAttachment> Attachments => this._attachments;
+        internal readonly List<DiscordAttachment> _attachments = new();
 
         /// <summary>
         /// Gets the Reply Message ID.
         /// </summary>
         public ulong? ReplyId { get; private set; } = null;
 
         /// <summary>
         /// Gets if the Reply should mention the user.
         /// </summary>
         public bool MentionOnReply { get; private set; } = false;
 
         /// <summary>
         /// Gets if the embeds should be suppressed.
         /// </summary>
         public bool Suppressed { get; private set; } = false;
 
         /// <summary>
         /// Gets if the Reply will error if the Reply Message Id does not reference a valid message.
         /// <para>If set to false, invalid replies are send as a regular message.</para>
         /// <para>Defaults to false.</para>
         /// </summary>
         public bool FailOnInvalidReply { get; set; }
 
         /// <summary>
         /// Sets the Content of the Message.
         /// </summary>
         /// <param name="content">The content to be set.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithContent(string content)
         {
             this.Content = content;
             return this;
         }
 
         /// <summary>
         /// Adds a sticker to the message. Sticker must be from current guild.
         /// </summary>
         /// <param name="sticker">The sticker to add.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithSticker(DiscordSticker sticker)
         {
             this.Sticker = sticker;
             return this;
         }
 
         /// <summary>
         /// Adds a row of components to a message, up to 5 components per row, and up to 5 rows per message.
         /// </summary>
         /// <param name="components">The components to add to the message.</param>
         /// <returns>The current builder to be chained.</returns>
         /// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
         public DiscordMessageBuilder AddComponents(params DiscordComponent[] components)
             => this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
         /// <summary>
         /// Appends several rows of components to the message
         /// </summary>
         /// <param name="components">The rows of components to add, holding up to five each.</param>
         /// <returns></returns>
         public DiscordMessageBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
         {
             var ara = components.ToArray();
 
             if (ara.Length + this._components.Count > 5)
                 throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
             foreach (var ar in ara)
                 this._components.Add(ar);
 
             return this;
         }
 
         /// <summary>
         /// Adds a row of components to a message, up to 5 components per row, and up to 5 rows per message.
         /// </summary>
         /// <param name="components">The components to add to the message.</param>
         /// <returns>The current builder to be chained.</returns>
         /// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
         public DiscordMessageBuilder AddComponents(IEnumerable<DiscordComponent> components)
         {
             var cmpArr = components.ToArray();
             var count = cmpArr.Length;
 
             if (!cmpArr.Any())
                 throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
             if (count > 5)
                 throw new ArgumentException("Cannot add more than 5 components per action row!");
 
             var comp = new DiscordActionRowComponent(cmpArr);
             this._components.Add(comp);
 
             return this;
         }
 
         /// <summary>
         /// Sets if the message should be TTS.
         /// </summary>
         /// <param name="isTTS">If TTS should be set.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder HasTTS(bool isTTS)
         {
             this.IsTTS = isTTS;
             return this;
         }
 
         /// <summary>
         /// Sets the embed for the current builder.
         /// </summary>
         /// <param name="embed">The embed that should be set.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithEmbed(DiscordEmbed embed)
         {
             if (embed == null)
                 return this;
 
             this.Embed = embed;
             return this;
         }
 
         /// <summary>
         /// Appends an embed to the current builder.
         /// </summary>
         /// <param name="embed">The embed that should be appended.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder AddEmbed(DiscordEmbed embed)
         {
             if (embed == null)
                 return this; //Providing null embeds will produce a 400 response from Discord.//
             this._embeds.Add(embed);
             return this;
         }
 
         /// <summary>
         /// Appends several embeds to the current builder.
         /// </summary>
         /// <param name="embeds">The embeds that should be appended.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
         {
             this._embeds.AddRange(embeds);
             return this;
         }
 
         /// <summary>
         /// Sets if the message has allowed mentions.
         /// </summary>
         /// <param name="allowedMention">The allowed Mention that should be sent.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithAllowedMention(IMention allowedMention)
         {
             if (this.Mentions != null)
                 this.Mentions.Add(allowedMention);
             else
                 this.Mentions = new List<IMention> { allowedMention };
 
             return this;
         }
 
         /// <summary>
         /// Sets if the message has allowed mentions.
         /// </summary>
         /// <param name="allowedMentions">The allowed Mentions that should be sent.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithAllowedMentions(IEnumerable<IMention> allowedMentions)
         {
             if (this.Mentions != null)
                 this.Mentions.AddRange(allowedMentions);
             else
                 this.Mentions = allowedMentions.ToList();
 
             return this;
         }
 
         /// <summary>
         /// Sets if the message has files to be sent.
         /// </summary>
         /// <param name="fileName">The fileName that the file should be sent as.</param>
         /// <param name="stream">The Stream to the file.</param>
         /// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
         /// <param name="description">Description of the file.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithFile(string fileName, Stream stream, bool resetStreamPosition = false, string description = null)
         {
             if (this.Files.Count > 10)
                 throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
             if (this._files.Any(x => x.FileName == fileName))
                 throw new ArgumentException("A File with that filename already exists");
 
             if (resetStreamPosition)
                 this._files.Add(new DiscordMessageFile(fileName, stream, stream.Position, description: description));
             else
                 this._files.Add(new DiscordMessageFile(fileName, stream, null, description: description));
 
             return this;
         }
 
         /// <summary>
         /// Sets if the message has files to be sent.
         /// </summary>
         /// <param name="stream">The Stream to the file.</param>
         /// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
         /// <param name="description">Description of the file.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithFile(FileStream stream, bool resetStreamPosition = false, string description = null)
         {
             if (this.Files.Count > 10)
                 throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
             if (this._files.Any(x => x.FileName == stream.Name))
                 throw new ArgumentException("A File with that filename already exists");
 
             if (resetStreamPosition)
                 this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
             else
                 this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
             return this;
         }
 
         /// <summary>
         /// Sets if the message has files to be sent.
         /// </summary>
         /// <param name="files">The Files that should be sent.</param>
         /// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
         {
             if (this.Files.Count + files.Count > 10)
                 throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
             foreach (var file in files)
             {
                 if (this._files.Any(x => x.FileName == file.Key))
                     throw new ArgumentException("A File with that filename already exists");
 
                 if (resetStreamPosition)
                     this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
                 else
                     this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
             }
 
             return this;
         }
 
+        /// <summary>
+        /// Modifies the given attachments on edit.
+        /// </summary>
+        /// <param name="attachments">Attachments to edit.</param>
+        /// <returns></returns>
+        public DiscordMessageBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
+        {
+            this._attachments.AddRange(attachments);
+            return this;
+        }
+
+        /// <summary>
+        /// Whether to keep the message attachments, if new ones are added.
+        /// </summary>
+        /// <returns></returns>
+        public DiscordMessageBuilder KeepAttachments(bool keep)
+        {
+            this._keepAttachments = keep;
+            return this;
+        }
+
         /// <summary>
         /// Sets if the message is a reply
         /// </summary>
         /// <param name="messageId">The ID of the message to reply to.</param>
         /// <param name="mention">If we should mention the user in the reply.</param>
         /// <param name="failOnInvalidReply">Whether sending a reply that references an invalid message should be </param>
         /// <returns>The current builder to be chained.</returns>
         public DiscordMessageBuilder WithReply(ulong messageId, bool mention = false, bool failOnInvalidReply = false)
         {
             this.ReplyId = messageId;
             this.MentionOnReply = mention;
             this.FailOnInvalidReply = failOnInvalidReply;
 
             if (mention)
             {
                 this.Mentions ??= new List<IMention>();
                 this.Mentions.Add(new RepliedUserMention());
             }
 
             return this;
         }
 
 
         /// <summary>
         /// Sends the Message to a specific channel
         /// </summary>
         /// <param name="channel">The channel the message should be sent to.</param>
         /// <returns>The current builder to be chained.</returns>
         public Task<DiscordMessage> SendAsync(DiscordChannel channel) => channel.SendMessageAsync(this);
 
         /// <summary>
         /// Sends the modified message.
         /// <para>Note: Message replies cannot be modified. To clear the reply, simply pass <see langword="null"/> to <see cref="WithReply"/>.</para>
         /// </summary>
         /// <param name="msg">The original Message to modify.</param>
         /// <returns>The current builder to be chained.</returns>
         public Task<DiscordMessage> ModifyAsync(DiscordMessage msg) => msg.ModifyAsync(this);
 
         /// <summary>
         /// Clears all message components on this builder.
         /// </summary>
         public void ClearComponents()
             => this._components.Clear();
 
         /// <summary>
         /// Allows for clearing the Message Builder so that it can be used again to send a new message.
         /// </summary>
         public void Clear()
         {
             this.Content = "";
             this._embeds.Clear();
             this.IsTTS = false;
             this.Mentions = null;
             this._files.Clear();
             this.ReplyId = null;
             this.MentionOnReply = false;
             this._components.Clear();
             this.Suppressed = false;
             this.Sticker = null;
-            this.Attachments.Clear();
+            this._attachments.Clear();
+            this._keepAttachments = false;
         }
 
         /// <summary>
         /// Does the validation before we send a the Create/Modify request.
         /// </summary>
         /// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
         internal void Validate(bool isModify = false)
         {
             if (this._embeds.Count > 10)
                 throw new ArgumentException("A message can only have up to 10 embeds.");
 
             if (!isModify)
             {
                 if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && (!this.Embeds?.Any() ?? true) && this.Sticker is null)
                     throw new ArgumentException("You must specify content, an embed, a sticker or at least one file.");
 
                 if (this.Components.Count > 5)
                     throw new InvalidOperationException("You can only have 5 action rows per message.");
 
                 if (this.Components.Any(c => c.Components.Count > 5))
                     throw new InvalidOperationException("Action rows can only have 5 components");
             }
         }
     }
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhook.cs b/DisCatSharp/Entities/Webhook/DiscordWebhook.cs
index fa676d04b..21d00fcd7 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhook.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhook.cs
@@ -1,280 +1,286 @@
 // 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.IO;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents information about a Discord webhook.
     /// </summary>
     public class DiscordWebhook : SnowflakeObject, IEquatable<DiscordWebhook>
     {
         /// <summary>
         /// Gets the api client.
         /// </summary>
         internal DiscordApiClient ApiClient { get; set; }
 
         /// <summary>
         /// Gets the ID of the guild this webhook belongs to.
         /// </summary>
         [JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong GuildId { get; internal set; }
 
         /// <summary>
         /// Gets the ID of the channel this webhook belongs to.
         /// </summary>
         [JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong ChannelId { get; internal set; }
 
         /// <summary>
         /// Gets the user this webhook was created by.
         /// </summary>
         [JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordUser User { get; internal set; }
 
         /// <summary>
         /// Gets the default name of this webhook.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; internal set; }
 
         /// <summary>
         /// Gets hash of the default avatar for this webhook.
         /// </summary>
         [JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
         internal string AvatarHash { get; set; }
 
         /// <summary>
         /// Gets the partial source guild for this webhook (For Channel Follower Webhooks).
         /// </summary>
         [JsonProperty("source_guild", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordGuild SourceGuild { get; set; }
 
         /// <summary>
         /// Gets the partial source channel for this webhook (For Channel Follower Webhooks).
         /// </summary>
         [JsonProperty("source_channel", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordChannel SourceChannel { get; set; }
 
         /// <summary>
         /// Gets the url used for executing the webhook.
         /// </summary>
         [JsonProperty("url", NullValueHandling = NullValueHandling.Ignore)]
         public string Url { get; set; }
 
         /// <summary>
         /// Gets the default avatar url for this webhook.
         /// </summary>
         public string AvatarUrl
             => !string.IsNullOrWhiteSpace(this.AvatarHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{this.Id}/{this.AvatarHash}.png?size=1024" : null;
 
         /// <summary>
         /// Gets the secure token of this webhook.
         /// </summary>
         [JsonProperty("token", NullValueHandling = NullValueHandling.Ignore)]
         public string Token { get; internal set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordWebhook"/> class.
         /// </summary>
         internal DiscordWebhook() { }
 
         /// <summary>
         /// Modifies this webhook.
         /// </summary>
         /// <param name="name">New default name for this webhook.</param>
         /// <param name="avatar">New avatar for this webhook.</param>
         /// <param name="channelId">The new channel id to move the webhook to.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The modified webhook.</returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordWebhook> ModifyAsync(string name = null, Optional<Stream> avatar = default, ulong? channelId = null, string reason = null)
         {
             var avatarb64 = Optional.FromNoValue<string>();
             if (avatar.HasValue && avatar.Value != null)
                 using (var imgtool = new ImageTool(avatar.Value))
                     avatarb64 = imgtool.GetBase64();
             else if (avatar.HasValue)
                 avatarb64 = null;
 
             var newChannelId = channelId ?? this.ChannelId;
 
             return this.Discord.ApiClient.ModifyWebhookAsync(this.Id, newChannelId, name, avatarb64, reason);
         }
 
         /// <summary>
         /// Gets a previously-sent webhook message.
         /// </summary>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> GetMessageAsync(ulong messageId)
             => await (this.Discord?.ApiClient ?? this.ApiClient).GetWebhookMessageAsync(this.Id, this.Token, messageId).ConfigureAwait(false);
 
         /// <summary>
         /// Gets a previously-sent webhook message.
         /// </summary>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> GetMessageAsync(ulong messageId, ulong threadId)
             => await (this.Discord?.ApiClient ?? this.ApiClient).GetWebhookMessageAsync(this.Id, this.Token, messageId, threadId).ConfigureAwait(false);
 
         /// <summary>
         /// Permanently deletes this webhook.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAsync()
             => this.Discord.ApiClient.DeleteWebhookAsync(this.Id, this.Token);
 
         /// <summary>
         /// Executes this webhook with the given <see cref="DiscordWebhookBuilder"/>.
         /// </summary>
         /// <param name="builder">Webhook builder filled with data to send.</param>
         /// <param name="thread_id">Target thread id (Optional). Defaults to null.</param>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordMessage> ExecuteAsync(DiscordWebhookBuilder builder, string thread_id = null)
             => (this.Discord?.ApiClient ?? this.ApiClient).ExecuteWebhookAsync(this.Id, this.Token, builder, thread_id);
 
         /// <summary>
         /// Executes this webhook in Slack compatibility mode.
         /// </summary>
         /// <param name="json">JSON containing Slack-compatible payload for this webhook.</param>
         /// <param name="thread_id">Target thread id (Optional). Defaults to null.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ExecuteSlackAsync(string json, string thread_id = null)
             => (this.Discord?.ApiClient ?? this.ApiClient).ExecuteWebhookSlackAsync(this.Id, this.Token, json, thread_id);
 
         /// <summary>
         /// Executes this webhook in GitHub compatibility mode.
         /// </summary>
         /// <param name="json">JSON containing GitHub-compatible payload for this webhook.</param>
         /// <param name="thread_id">Target thread id (Optional). Defaults to null.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ExecuteGithubAsync(string json, string thread_id = null)
             => (this.Discord?.ApiClient ?? this.ApiClient).ExecuteWebhookGithubAsync(this.Id, this.Token, json, thread_id);
 
         /// <summary>
         /// Edits a previously-sent webhook message.
         /// </summary>
         /// <param name="messageId">The id of the message to edit.</param>
         /// <param name="builder">The builder of the message to edit.</param>
         /// <param name="thread_id">Target thread id (Optional). Defaults to null.</param>
         /// <returns>The modified <see cref="DiscordMessage"/></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMessage> EditMessageAsync(ulong messageId, DiscordWebhookBuilder builder, string thread_id = null)
         {
             builder.Validate(true);
-
+            if (builder._keepAttachments.HasValue && builder._keepAttachments.Value)
+            {
+                builder._attachments.AddRange(this.ApiClient.GetWebhookMessageAsync(this.Id, this.Token, messageId.ToString(), thread_id).Result.Attachments);
+            } else if (builder._keepAttachments.HasValue)
+            {
+                builder._attachments.Clear();
+            }
             return await (this.Discord?.ApiClient ?? this.ApiClient).EditWebhookMessageAsync(this.Id, this.Token, messageId.ToString(), builder, thread_id).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a message that was created by the webhook.
         /// </summary>
         /// <param name="messageId">The id of the message to delete</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteMessageAsync(ulong messageId)
             => (this.Discord?.ApiClient ?? this.ApiClient).DeleteWebhookMessageAsync(this.Id, this.Token, messageId);
 
         /// <summary>
         /// Deletes a message that was created by the webhook.
         /// </summary>
         /// <param name="messageId">The id of the message to delete</param>
         /// <param name="threadId">Target thread id (Optional). Defaults to null.</param>
         /// <returns></returns>
         /// <exception cref="Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
         /// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteMessageAsync(ulong messageId, ulong threadId)
             => (this.Discord?.ApiClient ?? this.ApiClient).DeleteWebhookMessageAsync(this.Id, this.Token, messageId, threadId);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordWebhook"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordWebhook"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordWebhook);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordWebhook"/> is equal to another <see cref="DiscordWebhook"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordWebhook"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordWebhook"/> is equal to this <see cref="DiscordWebhook"/>.</returns>
         public bool Equals(DiscordWebhook e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordWebhook"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordWebhook"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordWebhook"/> objects are equal.
         /// </summary>
         /// <param name="e1">First webhook to compare.</param>
         /// <param name="e2">Second webhook to compare.</param>
         /// <returns>Whether the two webhooks are equal.</returns>
         public static bool operator ==(DiscordWebhook e1, DiscordWebhook e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordWebhook"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First webhook to compare.</param>
         /// <param name="e2">Second webhook to compare.</param>
         /// <returns>Whether the two webhooks are not equal.</returns>
         public static bool operator !=(DiscordWebhook e1, DiscordWebhook e2)
             => !(e1 == e2);
     }
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
index 7e2412eea..4c5f63ba3 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
@@ -1,426 +1,442 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Constructs ready-to-send webhook requests.
     /// </summary>
     public sealed class DiscordWebhookBuilder
     {
         /// <summary>
         /// Username to use for this webhook request.
         /// </summary>
         public Optional<string> Username { get; set; }
 
         /// <summary>
         /// Avatar url to use for this webhook request.
         /// </summary>
         public Optional<string> AvatarUrl { get; set; }
 
         /// <summary>
         /// Whether this webhook request is text-to-speech.
         /// </summary>
         public bool IsTTS { get; set; }
 
         /// <summary>
         /// Message to send on this webhook request.
         /// </summary>
         public string Content
         {
             get => this._content;
             set
             {
                 if (value != null && value.Length > 2000)
                     throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
                 this._content = value;
             }
         }
         private string _content;
 
+        /// <summary>
+        /// Whether to keep previous attachments.
+        /// </summary>
+        internal bool? _keepAttachments = null;
+
         /// <summary>
         /// Embeds to send on this webhook request.
         /// </summary>
         public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
         private readonly List<DiscordEmbed> _embeds = new();
 
         /// <summary>
         /// Files to send on this webhook request.
         /// </summary>
         public IReadOnlyList<DiscordMessageFile> Files => this._files;
         private readonly List<DiscordMessageFile> _files = new();
 
         /// <summary>
         /// Mentions to send on this webhook request.
         /// </summary>
         public IReadOnlyList<IMention> Mentions => this._mentions;
         private readonly List<IMention> _mentions = new();
 
         /// <summary>
         /// Gets the components.
         /// </summary>
         public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
         private readonly List<DiscordActionRowComponent> _components = new();
 
 
         /// <summary>
         /// Attachments to keep on this webhook request.
         /// </summary>
         public IEnumerable<DiscordAttachment> Attachments => this._attachments;
-        private readonly List<DiscordAttachment> _attachments = new();
+        internal readonly List<DiscordAttachment> _attachments = new();
 
         /// <summary>
         /// Constructs a new empty webhook request builder.
         /// </summary>
         public DiscordWebhookBuilder() { } // I still see no point in initializing collections with empty collections. //
 
 
         /// <summary>
         /// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
         /// </summary>
         /// <param name="components">The components to add to the builder.</param>
         /// <returns>The current builder to be chained.</returns>
         /// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
         public DiscordWebhookBuilder AddComponents(params DiscordComponent[] components)
             => this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
         /// <summary>
         /// Appends several rows of components to the builder
         /// </summary>
         /// <param name="components">The rows of components to add, holding up to five each.</param>
         /// <returns></returns>
         public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
         {
             var ara = components.ToArray();
 
             if (ara.Length + this._components.Count > 5)
                 throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
             foreach (var ar in ara)
                 this._components.Add(ar);
 
             return this;
         }
 
         /// <summary>
         /// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
         /// </summary>
         /// <param name="components">The components to add to the builder.</param>
         /// <returns>The current builder to be chained.</returns>
         /// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
         public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordComponent> components)
         {
             var cmpArr = components.ToArray();
             var count = cmpArr.Length;
 
             if (!cmpArr.Any())
                 throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
             if (count > 5)
                 throw new ArgumentException("Cannot add more than 5 components per action row!");
 
             var comp = new DiscordActionRowComponent(cmpArr);
             this._components.Add(comp);
 
             return this;
         }
 
         /// <summary>
         /// Sets the username for this webhook builder.
         /// </summary>
         /// <param name="username">Username of the webhook</param>
         public DiscordWebhookBuilder WithUsername(string username)
         {
             this.Username = username;
             return this;
         }
 
         /// <summary>
         /// Sets the avatar of this webhook builder from its url.
         /// </summary>
         /// <param name="avatarUrl">Avatar url of the webhook</param>
         public DiscordWebhookBuilder WithAvatarUrl(string avatarUrl)
         {
             this.AvatarUrl = avatarUrl;
             return this;
         }
 
         /// <summary>
         /// Indicates if the webhook must use text-to-speech.
         /// </summary>
         /// <param name="tts">Text-to-speech</param>
         public DiscordWebhookBuilder WithTTS(bool tts)
         {
             this.IsTTS = tts;
             return this;
         }
 
         /// <summary>
         /// Sets the message to send at the execution of the webhook.
         /// </summary>
         /// <param name="content">Message to send.</param>
         public DiscordWebhookBuilder WithContent(string content)
         {
             this.Content = content;
             return this;
         }
 
         /// <summary>
         /// Adds an embed to send at the execution of the webhook.
         /// </summary>
         /// <param name="embed">Embed to add.</param>
         public DiscordWebhookBuilder AddEmbed(DiscordEmbed embed)
         {
             if (embed != null)
                 this._embeds.Add(embed);
 
             return this;
         }
 
         /// <summary>
         /// Adds the given embeds to send at the execution of the webhook.
         /// </summary>
         /// <param name="embeds">Embeds to add.</param>
         public DiscordWebhookBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
         {
             this._embeds.AddRange(embeds);
             return this;
         }
 
         /// <summary>
         /// Adds a file to send at the execution of the webhook.
         /// </summary>
         /// <param name="filename">Name of the file.</param>
         /// <param name="data">File data.</param>
         /// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
         /// <param name="description">Description of the file.</param>
         public DiscordWebhookBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false, string description = null)
         {
             if (this.Files.Count() > 10)
                 throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
             if (this._files.Any(x => x.FileName == filename))
                 throw new ArgumentException("A File with that filename already exists");
 
             if (resetStreamPosition)
                 this._files.Add(new DiscordMessageFile(filename, data, data.Position, description: description));
             else
                 this._files.Add(new DiscordMessageFile(filename, data, null, description: description));
 
             return this;
         }
 
         /// <summary>
         /// Sets if the message has files to be sent.
         /// </summary>
         /// <param name="stream">The Stream to the file.</param>
         /// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
         /// <param name="description">Description of the file.</param>
         /// <returns></returns>
         public DiscordWebhookBuilder AddFile(FileStream stream, bool resetStreamPosition = false, string description = null)
         {
             if (this.Files.Count() > 10)
                 throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
             if (this._files.Any(x => x.FileName == stream.Name))
                 throw new ArgumentException("A File with that filename already exists");
 
             if (resetStreamPosition)
                 this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
             else
                 this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
             return this;
         }
 
         /// <summary>
         /// Adds the given files to send at the execution of the webhook.
         /// </summary>
         /// <param name="files">Dictionary of file name and file data.</param>
         /// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
         public DiscordWebhookBuilder AddFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
         {
             if (this.Files.Count() + files.Count() > 10)
                 throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
             foreach (var file in files)
             {
                 if (this._files.Any(x => x.FileName == file.Key))
                     throw new ArgumentException("A File with that filename already exists");
 
                 if (resetStreamPosition)
                     this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
                 else
                     this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
             }
 
 
             return this;
         }
 
         /// <summary>
-        /// Keeps the given attachments on edit.
+        /// Modifies the given attachments on edit.
         /// </summary>
-        /// <param name="attachments">Attachments to keep (on edit).</param>
+        /// <param name="attachments">Attachments to edit.</param>
         /// <returns></returns>
-        public DiscordWebhookBuilder KeepAttachments(IEnumerable<DiscordAttachment> attachments)
+        public DiscordWebhookBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
         {
             this._attachments.AddRange(attachments);
             return this;
         }
 
+        /// <summary>
+        /// Whether to keep the message attachments, if new ones are added.
+        /// </summary>
+        /// <returns></returns>
+        public DiscordWebhookBuilder KeepAttachments(bool keep)
+        {
+            this._keepAttachments = keep;
+            return this;
+        }
+
         /// <summary>
         /// Adds the mention to the mentions to parse, etc. at the execution of the webhook.
         /// </summary>
         /// <param name="mention">Mention to add.</param>
         public DiscordWebhookBuilder AddMention(IMention mention)
         {
             this._mentions.Add(mention);
             return this;
         }
 
         /// <summary>
         /// Adds the mentions to the mentions to parse, etc. at the execution of the webhook.
         /// </summary>
         /// <param name="mentions">Mentions to add.</param>
         public DiscordWebhookBuilder AddMentions(IEnumerable<IMention> mentions)
         {
             this._mentions.AddRange(mentions);
             return this;
         }
 
         /// <summary>
         /// Executes a webhook.
         /// </summary>
         /// <param name="webhook">The webhook that should be executed.</param>
         /// <returns>The message sent</returns>
         public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook) => await webhook.ExecuteAsync(this).ConfigureAwait(false);
 
         /// <summary>
         /// Executes a webhook.
         /// </summary>
         /// <param name="webhook">The webhook that should be executed.</param>
         /// <param name="threadId">Target thread id.</param>
         /// <returns>The message sent</returns>
         public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook, ulong threadId) => await webhook.ExecuteAsync(this, threadId.ToString()).ConfigureAwait(false);
 
         /// <summary>
         /// Sends the modified webhook message.
         /// </summary>
         /// <param name="webhook">The webhook that should be executed.</param>
         /// <param name="message">The message to modify.</param>
         /// <returns>The modified message</returns>
         public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message) => await this.ModifyAsync(webhook, message.Id).ConfigureAwait(false);
 
         /// <summary>
         /// Sends the modified webhook message.
         /// </summary>
         /// <param name="webhook">The webhook that should be executed.</param>
         /// <param name="messageId">The id of the message to modify.</param>
         /// <returns>The modified message</returns>
         public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId) => await webhook.EditMessageAsync(messageId, this).ConfigureAwait(false);
 
         /// <summary>
         /// Sends the modified webhook message.
         /// </summary>
         /// <param name="webhook">The webhook that should be executed.</param>
         /// <param name="message">The message to modify.</param>
         /// <param name="thread">Target thread.</param>
         /// <returns>The modified message</returns>
         public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message, DiscordThreadChannel thread) => await this.ModifyAsync(webhook, message.Id, thread.Id).ConfigureAwait(false);
 
         /// <summary>
         /// Sends the modified webhook message.
         /// </summary>
         /// <param name="webhook">The webhook that should be executed.</param>
         /// <param name="messageId">The id of the message to modify.</param>
         /// <param name="threadId">Target thread id.</param>
         /// <returns>The modified message</returns>
         public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId, ulong threadId) => await webhook.EditMessageAsync(messageId, this, threadId.ToString()).ConfigureAwait(false);
 
         /// <summary>
         /// Clears all message components on this builder.
         /// </summary>
         public void ClearComponents()
             => this._components.Clear();
 
         /// <summary>
         /// Allows for clearing the Webhook Builder so that it can be used again to send a new message.
         /// </summary>
         public void Clear()
         {
             this.Content = "";
             this._embeds.Clear();
             this.IsTTS = false;
             this._mentions.Clear();
             this._files.Clear();
             this._attachments.Clear();
             this._components.Clear();
+            this._keepAttachments = false;
         }
 
         /// <summary>
         /// Does the validation before we send a the Create/Modify request.
         /// </summary>
         /// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
         /// <param name="isFollowup">Tells the method to perform the follow up message validation.</param>
         /// <param name="isInteractionResponse">Tells the method to perform the interaction response validation.</param>
         internal void Validate(bool isModify = false, bool isFollowup = false, bool isInteractionResponse = false)
         {
             if (isModify)
             {
                 if (this.Username.HasValue)
                     throw new ArgumentException("You cannot change the username of a message.");
 
                 if (this.AvatarUrl.HasValue)
                     throw new ArgumentException("You cannot change the avatar of a message.");
             }
             else if (isFollowup)
             {
                 if (this.Username.HasValue)
                     throw new ArgumentException("You cannot change the username of a follow up message.");
 
                 if (this.AvatarUrl.HasValue)
                     throw new ArgumentException("You cannot change the avatar of a follow up message.");
             }
             else if (isInteractionResponse)
             {
                 if (this.Username.HasValue)
                     throw new ArgumentException("You cannot change the username of an interaction response.");
 
                 if (this.AvatarUrl.HasValue)
                     throw new ArgumentException("You cannot change the avatar of an interaction response.");
             }
             else
             {
                 if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && !this.Embeds.Any())
                     throw new ArgumentException("You must specify content, an embed, or at least one file.");
             }
         }
     }
 }
diff --git a/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
index a4b87af6c..b767b05f1 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
@@ -1,503 +1,503 @@
 // 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.Collections.Generic;
 using DisCatSharp.Entities;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions
 {
     /// <summary>
     /// Represents a channel create payload.
     /// </summary>
     internal sealed class RestChannelCreatePayload
     {
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         [JsonProperty("name")]
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the type.
         /// </summary>
         [JsonProperty("type")]
         public ChannelType Type { get; set; }
 
         /// <summary>
         /// Gets or sets the parent.
         /// </summary>
         [JsonProperty("parent_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? Parent { get; set; }
 
         /// <summary>
         /// Gets or sets the topic.
         /// </summary>
         [JsonProperty("topic")]
         public Optional<string> Topic { get; set; }
 
         /// <summary>
         /// Gets or sets the bitrate.
         /// </summary>
         [JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
         public int? Bitrate { get; set; }
 
         /// <summary>
         /// Gets or sets the user limit.
         /// </summary>
         [JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
         public int? UserLimit { get; set; }
 
         /// <summary>
         /// Gets or sets the permission overwrites.
         /// </summary>
         [JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
         public IEnumerable<DiscordRestOverwrite> PermissionOverwrites { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether nsfw.
         /// </summary>
         [JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
         public bool? Nsfw { get; set; }
 
         /// <summary>
         /// Gets or sets the per user rate limit.
         /// </summary>
         [JsonProperty("rate_limit_per_user")]
         public Optional<int?> PerUserRateLimit { get; set; }
 
         /// <summary>
         /// Gets or sets the quality mode.
         /// </summary>
         [JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
         public VideoQualityMode? QualityMode { get; set; }
 
         /// <summary>
         /// Gets or sets the default auto archive duration.
         /// </summary>
         [JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
         public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; set; }
     }
 
     /// <summary>
     /// Represents a channel modify payload.
     /// </summary>
     internal sealed class RestChannelModifyPayload
     {
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the type.
         /// </summary>
         [JsonProperty("type")]
         public Optional<ChannelType> Type { get; set; }
 
         /// <summary>
         /// Gets or sets the position.
         /// </summary>
         [JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
         public int? Position { get; set; }
 
         /// <summary>
         /// Gets or sets the topic.
         /// </summary>
         [JsonProperty("topic")]
         public Optional<string> Topic { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether nsfw.
         /// </summary>
         [JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
         public bool? Nsfw { get; set; }
 
         /// <summary>
         /// Gets or sets the parent.
         /// </summary>
         [JsonProperty("parent_id")]
         public Optional<ulong?> Parent { get; set; }
 
         /// <summary>
         /// Gets or sets the bitrate.
         /// </summary>
         [JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
         public int? Bitrate { get; set; }
 
         /// <summary>
         /// Gets or sets the user limit.
         /// </summary>
         [JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
         public int? UserLimit { get; set; }
 
         /// <summary>
         /// Gets or sets the per user rate limit.
         /// </summary>
         [JsonProperty("rate_limit_per_user")]
         public Optional<int?> PerUserRateLimit { get; set; }
 
         /// <summary>
         /// Gets or sets the rtc region.
         /// </summary>
         [JsonProperty("rtc_region")]
         public Optional<string> RtcRegion { get; set; }
 
         /// <summary>
         /// Gets or sets the quality mode.
         /// </summary>
         [JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
         public VideoQualityMode? QualityMode { get; set; }
 
         /// <summary>
         /// Gets or sets the default auto archive duration.
         /// </summary>
         [JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
         public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; set; }
 
         /// <summary>
         /// Gets or sets the permission overwrites.
         /// </summary>
         [JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
         public IEnumerable<DiscordRestOverwrite> PermissionOverwrites { get; set; }
 
         /// <summary>
         /// Gets or sets the banner base64.
         /// </summary>
         [JsonProperty("banner")]
         public Optional<string> BannerBase64 { get; set; }
     }
 
     /// <summary>
     /// Represents a channel message edit payload.
     /// </summary>
     internal class RestChannelMessageEditPayload
     {
         /// <summary>
         /// Gets or sets the content.
         /// </summary>
         [JsonProperty("content", NullValueHandling = NullValueHandling.Include)]
         public string Content { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether has content.
         /// </summary>
         [JsonIgnore]
         public bool HasContent { get; set; }
 
         /// <summary>
         /// Gets or sets the embeds.
         /// </summary>
         [JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
         public IEnumerable<DiscordEmbed> Embeds { get; set; }
 
         /// <summary>
         /// Gets or sets the mentions.
         /// </summary>
         [JsonProperty("allowed_mentions", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordMentions Mentions { get; set; }
 
         /// <summary>
         /// Gets or sets the attachments.
         /// </summary>
         [JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
-        public List<DiscordAttachment> Attachments { get; set; }
+        public IEnumerable<DiscordAttachment> Attachments { get; set; }
 
         /// <summary>
         /// Gets or sets the flags.
         /// </summary>
         [JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
         public MessageFlags? Flags{ get; set; }
 
         /// <summary>
         /// Gets or sets the components.
         /// </summary>
         [JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
         public IReadOnlyCollection<DiscordActionRowComponent> Components { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether has embed.
         /// </summary>
         [JsonIgnore]
         public bool HasEmbed { get; set; }
 
         /// <summary>
         /// Should serialize the content.
         /// </summary>
         public bool ShouldSerializeContent()
             => this.HasContent;
 
         /// <summary>
         /// Should serialize the embed.
         /// </summary>
         public bool ShouldSerializeEmbed()
             => this.HasEmbed;
     }
 
     /// <summary>
     /// Represents a channel message create payload.
     /// </summary>
     internal sealed class RestChannelMessageCreatePayload : RestChannelMessageEditPayload
     {
         /// <summary>
         /// Gets or sets a value indicating whether t t is s.
         /// </summary>
         [JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
         public bool? IsTTS { get; set; }
 
         /// <summary>
         /// Gets or sets the stickers ids.
         /// </summary>
         [JsonProperty("sticker_ids", NullValueHandling = NullValueHandling.Ignore)]
         public IEnumerable<ulong> StickersIds { get; set; }
 
         /// <summary>
         /// Gets or sets the message reference.
         /// </summary>
         [JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
         public InternalDiscordMessageReference? MessageReference { get; set; }
 
     }
 
     /// <summary>
     /// Represents a channel message create multipart payload.
     /// </summary>
     internal sealed class RestChannelMessageCreateMultipartPayload
     {
         /// <summary>
         /// Gets or sets the content.
         /// </summary>
         [JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
         public string Content { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether t t is s.
         /// </summary>
         [JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
         public bool? IsTTS { get; set; }
 
         /// <summary>
         /// Gets or sets the embeds.
         /// </summary>
         [JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
         public IEnumerable<DiscordEmbed> Embeds { get; set; }
 
         /// <summary>
         /// Gets or sets the mentions.
         /// </summary>
         [JsonProperty("allowed_mentions", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordMentions Mentions { get; set; }
 
         /// <summary>
         /// Gets or sets the message reference.
         /// </summary>
         [JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
         public InternalDiscordMessageReference? MessageReference { get; set; }
     }
 
     /// <summary>
     /// Represents a channel message bulk delete payload.
     /// </summary>
     internal sealed class RestChannelMessageBulkDeletePayload
     {
         /// <summary>
         /// Gets or sets the messages.
         /// </summary>
         [JsonProperty("messages", NullValueHandling = NullValueHandling.Ignore)]
         public IEnumerable<ulong> Messages { get; set; }
     }
 
     /// <summary>
     /// Represents a channel invite create payload.
     /// </summary>
     internal sealed class RestChannelInviteCreatePayload
     {
         /// <summary>
         /// Gets or sets the max age.
         /// </summary>
         [JsonProperty("max_age", NullValueHandling = NullValueHandling.Ignore)]
         public int MaxAge { get; set; }
 
         /// <summary>
         /// Gets or sets the max uses.
         /// </summary>
         [JsonProperty("max_uses", NullValueHandling = NullValueHandling.Ignore)]
         public int MaxUses { get; set; }
 
         /// <summary>
         /// Gets or sets the target type.
         /// </summary>
         [JsonProperty("target_type", NullValueHandling = NullValueHandling.Ignore)]
         public TargetType? TargetType{ get; set; }
 
         /// <summary>
         /// Gets or sets the target application.
         /// </summary>
         [JsonProperty("target_application_id", NullValueHandling = NullValueHandling.Ignore)]
         public TargetActivity? TargetApplication { get; set; }
 
         /// <summary>
         /// Gets or sets the target user id.
         /// </summary>
         [JsonProperty("target_user_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? TargetUserId { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether temporary.
         /// </summary>
         [JsonProperty("temporary", NullValueHandling = NullValueHandling.Ignore)]
         public bool Temporary { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether unique.
         /// </summary>
         [JsonProperty("unique", NullValueHandling = NullValueHandling.Ignore)]
         public bool Unique { get; set; }
     }
 
     /// <summary>
     /// Represents a channel permission edit payload.
     /// </summary>
     internal sealed class RestChannelPermissionEditPayload
     {
         /// <summary>
         /// Gets or sets the allow.
         /// </summary>
         [JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
         public Permissions Allow { get; set; }
 
         /// <summary>
         /// Gets or sets the deny.
         /// </summary>
         [JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
         public Permissions Deny { get; set; }
 
         /// <summary>
         /// Gets or sets the type.
         /// </summary>
         [JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
         public string Type { get; set; }
     }
 
     /// <summary>
     /// Represents a channel group dm recipient add payload.
     /// </summary>
     internal sealed class RestChannelGroupDmRecipientAddPayload : IOAuth2Payload
     {
         /// <summary>
         /// Gets or sets the access token.
         /// </summary>
         [JsonProperty("access_token")]
         public string AccessToken { get; set; }
 
         /// <summary>
         /// Gets or sets the nickname.
         /// </summary>
         [JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
         public string Nickname { get; set; }
     }
 
     /// <summary>
     /// The acknowledge payload.
     /// </summary>
     internal sealed class AcknowledgePayload
     {
         /// <summary>
         /// Gets or sets the token.
         /// </summary>
         [JsonProperty("token", NullValueHandling = NullValueHandling.Include)]
         public string Token { get; set; }
     }
 
     /// <summary>
     /// Represents a thread channel create payload.
     /// </summary>
     internal sealed class RestThreadChannelCreatePayload
     {
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         [JsonProperty("name")]
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the auto archive duration.
         /// </summary>
         [JsonProperty("auto_archive_duration")]
         public ThreadAutoArchiveDuration AutoArchiveDuration { get; set; }
 
         /// <summary>
         /// Gets or sets the rate limit per user.
         /// </summary>
         [JsonProperty("rate_limit_per_user")]
         public int? PerUserRateLimit { get; set; }
 
         /// <summary>
         /// Gets or sets the thread type.
         /// </summary>
         [JsonProperty("type")]
         public ChannelType Type { get; set; }
     }
 
     /// <summary>
     /// Represents a thread channel modify payload.
     /// </summary>
     internal sealed class RestThreadChannelModifyPayload
     {
         /// <summary>
         /// Gets or sets the name.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; set; }
 
         /// <summary>
         /// Gets or sets the archived.
         /// </summary>
         [JsonProperty("archived", NullValueHandling = NullValueHandling.Ignore)]
         public Optional<bool?> Archived { get; set; }
 
         /// <summary>
         /// Gets or sets the auto archive duration.
         /// </summary>
         [JsonProperty("auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
         public Optional<ThreadAutoArchiveDuration?> AutoArchiveDuration { get; set; }
 
         /// <summary>
         /// Gets or sets the locked.
         /// </summary>
         [JsonProperty("locked", NullValueHandling = NullValueHandling.Ignore)]
         public Optional<bool?> Locked { get; set; }
 
         /// <summary>
         /// Gets or sets the per user rate limit.
         /// </summary>
         [JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
         public Optional<int?> PerUserRateLimit { get; set; }
 
         /// <summary>
         /// Gets or sets the threads's invitable state.
         /// </summary>
         [JsonProperty("invitable", NullValueHandling = NullValueHandling.Ignore)]
         public Optional<bool?> Invitable { internal get; set; }
     }
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index eae9e9625..06faacdb8 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5352 +1,5396 @@
 // 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.Net;
 using System.Text;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
-using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net
 {
     /// <summary>
     /// Represents a discord api client.
     /// </summary>
     public sealed class DiscordApiClient
     {
         /// <summary>
         /// The audit log reason header name.
         /// </summary>
         private const string REASON_HEADER_NAME = "X-Audit-Log-Reason";
 
         /// <summary>
         /// Gets the discord client.
         /// </summary>
         internal BaseDiscordClient Discord { get; }
         /// <summary>
         /// Gets the rest client.
         /// </summary>
         internal RestClient Rest { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
         /// </summary>
         /// <param name="client">The client.</param>
         internal DiscordApiClient(BaseDiscordClient client)
         {
             this.Discord = client;
             this.Rest = new RestClient(client);
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
         /// </summary>
         /// <param name="proxy">The proxy.</param>
         /// <param name="timeout">The timeout.</param>
         /// <param name="useRelativeRateLimit">If true, use relative rate limit.</param>
         /// <param name="logger">The logger.</param>
         internal DiscordApiClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRateLimit, ILogger logger) // This is for meta-clients, such as the webhook client
         {
             this.Rest = new RestClient(proxy, timeout, useRelativeRateLimit, logger);
         }
 
         /// <summary>
         /// Builds the query string.
         /// </summary>
         /// <param name="values">The values.</param>
         /// <param name="post">If true, post.</param>
         /// <returns>A string.</returns>
         private static string BuildQueryString(IDictionary<string, string> values, bool post = false)
         {
             if (values == null || values.Count == 0)
                 return string.Empty;
 
             var vals_collection = values.Select(xkvp =>
                 $"{WebUtility.UrlEncode(xkvp.Key)}={WebUtility.UrlEncode(xkvp.Value)}");
             var vals = string.Join("&", vals_collection);
 
             return !post ? $"?{vals}" : vals;
         }
 
         /// <summary>
         /// Prepares the message.
         /// </summary>
         /// <param name="msg_raw">The msg_raw.</param>
         /// <returns>A DiscordMessage.</returns>
         private DiscordMessage PrepareMessage(JToken msg_raw)
         {
             var author = msg_raw["author"].ToObject<TransportUser>();
             var ret = msg_raw.ToDiscordObject<DiscordMessage>();
             ret.Discord = this.Discord;
 
             this.PopulateMessage(author, ret);
 
             var referencedMsg = msg_raw["referenced_message"];
             if (ret.MessageType == MessageType.Reply && !string.IsNullOrWhiteSpace(referencedMsg?.ToString()))
             {
                 author = referencedMsg["author"].ToObject<TransportUser>();
                 ret.ReferencedMessage.Discord = this.Discord;
                 this.PopulateMessage(author, ret.ReferencedMessage);
             }
 
             if (ret.Channel != null)
                 return ret;
 
             var channel = !ret.GuildId.HasValue
                 ? new DiscordDmChannel
                 {
                     Id = ret.ChannelId,
                     Discord = this.Discord,
                     Type = ChannelType.Private
                 }
                 : new DiscordChannel
                 {
                     Id = ret.ChannelId,
                     GuildId = ret.GuildId,
                     Discord = this.Discord
                 };
 
             ret.Channel = channel;
 
             return ret;
         }
 
         /// <summary>
         /// Populates the message.
         /// </summary>
         /// <param name="author">The author.</param>
         /// <param name="ret">The ret.</param>
         private void PopulateMessage(TransportUser author, DiscordMessage ret)
         {
             var guild = ret.Channel?.Guild;
 
             //If this is a webhook, it shouldn't be in the user cache.
             if (author.IsBot && int.Parse(author.Discriminator) == 0)
             {
                 ret.Author = new DiscordUser(author) { Discord = this.Discord };
             }
             else
             {
                 if (!this.Discord.UserCache.TryGetValue(author.Id, out var usr))
                 {
                     this.Discord.UserCache[author.Id] = usr = new DiscordUser(author) { Discord = this.Discord };
                 }
 
                 if (guild != null)
                 {
                     if (!guild.Members.TryGetValue(author.Id, out var mbr))
                         mbr = new DiscordMember(usr) { Discord = this.Discord, _guild_id = guild.Id };
                     ret.Author = mbr;
                 }
                 else
                 {
                     ret.Author = usr;
                 }
             }
 
             ret.PopulateMentions();
 
             if (ret._reactions == null)
                 ret._reactions = new List<DiscordReaction>();
             foreach (var xr in ret._reactions)
                 xr.Emoji.Discord = this.Discord;
         }
 
         /// <summary>
         /// Executes a rest request.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <param name="bucket">The bucket.</param>
         /// <param name="url">The url.</param>
         /// <param name="method">The method.</param>
         /// <param name="route">The route.</param>
         /// <param name="headers">The headers.</param>
         /// <param name="payload">The payload.</param>
         /// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
         /// <returns>A Task.</returns>
         internal Task<RestResponse> DoRequestAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, string payload = null, double? ratelimitWaitOverride = null)
         {
             var req = new RestRequest(client, bucket, url, method, route, headers, payload, ratelimitWaitOverride);
 
             if (this.Discord != null)
                 this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
             else
                 _ = this.Rest.ExecuteRequestAsync(req);
 
             return req.WaitForCompletionAsync();
         }
 
         /// <summary>
         /// Executes a multipart rest request for stickers.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <param name="bucket">The bucket.</param>
         /// <param name="url">The url.</param>
         /// <param name="method">The method.</param>
         /// <param name="route">The route.</param>
         /// <param name="headers">The headers.</param>
         /// <param name="file">The file.</param>
         /// <param name="name">The sticker name.</param>
         /// <param name="tags">The sticker tag.</param>
         /// <param name="description">The sticker description.</param>
         /// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
         /// <returns>A Task.</returns>
         private Task<RestResponse> DoStickerMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null,
             DiscordMessageFile file = null, string name = "", string tags = "", string description = "", double? ratelimitWaitOverride = null)
 {
             var req = new MultipartStickerWebRequest(client, bucket, url, method, route, headers, file, name, tags, description, ratelimitWaitOverride);
 
             if (this.Discord != null)
                 this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
             else
                 _ = this.Rest.ExecuteRequestAsync(req);
 
             return req.WaitForCompletionAsync();
         }
 
         /// <summary>
         /// Executes a multipart request.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <param name="bucket">The bucket.</param>
         /// <param name="url">The url.</param>
         /// <param name="method">The method.</param>
         /// <param name="route">The route.</param>
         /// <param name="headers">The headers.</param>
         /// <param name="values">The values.</param>
         /// <param name="files">The files.</param>
         /// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
         /// <returns>A Task.</returns>
         private Task<RestResponse> DoMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, IReadOnlyDictionary<string, string> values = null,
             IReadOnlyCollection<DiscordMessageFile> files = null, double? ratelimitWaitOverride = null)
         {
             var req = new MultipartWebRequest(client, bucket, url, method, route, headers, values, files, ratelimitWaitOverride);
 
             if (this.Discord != null)
                 this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
             else
                 _ = this.Rest.ExecuteRequestAsync(req);
 
             return req.WaitForCompletionAsync();
         }
 
         #region Guild
 
         /// <summary>
         /// Searches the members async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="limit">The limit.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(ulong guild_id, string name, int? limit)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.SEARCH}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
             var querydict = new Dictionary<string, string>
             {
                 ["query"] = name,
                 ["limit"] = limit.ToString()
             };
             var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
             var json = JArray.Parse(res.Response);
             var tms = json.ToObject<IReadOnlyList<TransportMember>>();
 
             var mbrs = new List<DiscordMember>();
             foreach (var xtm in tms)
             {
                 var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
                 this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
                 {
                     old.Username = usr.Username;
                     old.Discord = usr.Discord;
                     old.AvatarHash = usr.AvatarHash;
 
                     return old;
                 });
 
                 mbrs.Add(new DiscordMember(xtm) { Discord = this.Discord, _guild_id = guild_id });
             }
 
             return mbrs;
         }
 
         /// <summary>
         /// Gets the guild ban async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordBan> GetGuildBanAsync(ulong guild_id, ulong user_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id, user_id}, out var path);
             var uri = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, uri, RestRequestMethod.GET, route).ConfigureAwait(false);
             var json = JObject.Parse(res.Response);
 
             var ban = json.ToObject<DiscordBan>();
 
             return ban;
         }
 
         /// <summary>
         /// Creates the guild async.
         /// </summary>
         /// <param name="name">The name.</param>
         /// <param name="region_id">The region_id.</param>
         /// <param name="iconb64">The iconb64.</param>
         /// <param name="verification_level">The verification_level.</param>
         /// <param name="default_message_notifications">The default_message_notifications.</param>
         /// <param name="system_channel_flags">The system_channel_flags.</param>
         internal async Task<DiscordGuild> CreateGuildAsync(string name, string region_id, Optional<string> iconb64, VerificationLevel? verification_level,
             DefaultMessageNotifications? default_message_notifications, SystemChannelFlags? system_channel_flags)
         {
             var pld = new RestGuildCreatePayload
             {
                 Name = name,
                 RegionId = region_id,
                 DefaultMessageNotifications = default_message_notifications,
                 VerificationLevel = verification_level,
                 IconBase64 = iconb64,
                 SystemChannelFlags = system_channel_flags
 
             };
 
             var route = $"{Endpoints.GUILDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var raw_members = (JArray)json["members"];
             var guild = json.ToDiscordObject<DiscordGuild>();
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildCreateEventAsync(guild, raw_members, null).ConfigureAwait(false);
             return guild;
         }
 
         /// <summary>
         /// Creates the guild from template async.
         /// </summary>
         /// <param name="template_code">The template_code.</param>
         /// <param name="name">The name.</param>
         /// <param name="iconb64">The iconb64.</param>
         internal async Task<DiscordGuild> CreateGuildFromTemplateAsync(string template_code, string name, Optional<string> iconb64)
         {
             var pld = new RestGuildCreateFromTemplatePayload
             {
                 Name = name,
                 IconBase64 = iconb64
             };
 
             var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:template_code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { template_code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var raw_members = (JArray)json["members"];
             var guild = json.ToDiscordObject<DiscordGuild>();
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildCreateEventAsync(guild, raw_members, null).ConfigureAwait(false);
             return guild;
         }
 
         /// <summary>
         /// Deletes the guild async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         internal async Task DeleteGuildAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
             if (this.Discord is DiscordClient dc)
             {
                 var gld = dc._guilds[guild_id];
                 await dc.OnGuildDeleteEventAsync(gld).ConfigureAwait(false);
             }
         }
 
         /// <summary>
         /// Modifies the guild.
         /// </summary>
         /// <param name="guildId">The guild id.</param>
         /// <param name="name">The name.</param>
         /// <param name="verificationLevel">The verification level.</param>
         /// <param name="defaultMessageNotifications">The default message notifications.</param>
         /// <param name="mfaLevel">The mfa level.</param>
         /// <param name="explicitContentFilter">The explicit content filter.</param>
         /// <param name="afkChannelId">The afk channel id.</param>
         /// <param name="afkTimeout">The afk timeout.</param>
         /// <param name="iconb64">The iconb64.</param>
         /// <param name="ownerId">The owner id.</param>
         /// <param name="splashb64">The splashb64.</param>
         /// <param name="systemChannelId">The system channel id.</param>
         /// <param name="systemChannelFlags">The system channel flags.</param>
         /// <param name="publicUpdatesChannelId">The public updates channel id.</param>
         /// <param name="rulesChannelId">The rules channel id.</param>
         /// <param name="description">The description.</param>
         /// <param name="bannerb64">The banner base64.</param>
         /// <param name="discorverySplashb64">The discovery base64.</param>
         /// <param name="preferredLocale">The preferred locale.</param>
         /// <param name="premiumProgressBarEnabled">Whether the premium progress bar should be enabled.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordGuild> ModifyGuildAsync(ulong guildId, Optional<string> name, Optional<VerificationLevel> verificationLevel,
             Optional<DefaultMessageNotifications> defaultMessageNotifications, Optional<MfaLevel> mfaLevel,
             Optional<ExplicitContentFilter> explicitContentFilter, Optional<ulong?> afkChannelId,
             Optional<int> afkTimeout, Optional<string> iconb64, Optional<ulong> ownerId, Optional<string> splashb64,
             Optional<ulong?> systemChannelId, Optional<SystemChannelFlags> systemChannelFlags,
             Optional<ulong?> publicUpdatesChannelId, Optional<ulong?> rulesChannelId, Optional<string> description,
             Optional<string> bannerb64, Optional<string> discorverySplashb64, Optional<string> preferredLocale, Optional<bool> premiumProgressBarEnabled, string reason)
         {
             var pld = new RestGuildModifyPayload
             {
                 Name = name,
                 VerificationLevel = verificationLevel,
                 DefaultMessageNotifications = defaultMessageNotifications,
                 MfaLevel = mfaLevel,
                 ExplicitContentFilter = explicitContentFilter,
                 AfkChannelId = afkChannelId,
                 AfkTimeout = afkTimeout,
                 IconBase64 = iconb64,
                 SplashBase64 = splashb64,
                 BannerBase64 = bannerb64,
                 DiscoverySplashBase64 = discorverySplashb64,
                 OwnerId = ownerId,
                 SystemChannelId = systemChannelId,
                 SystemChannelFlags = systemChannelFlags,
                 RulesChannelId = rulesChannelId,
                 PublicUpdatesChannelId = publicUpdatesChannelId,
                 PreferredLocale = preferredLocale,
                 Description = description,
                 PremiumProgressBarEnabled = premiumProgressBarEnabled
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var rawMembers = (JArray)json["members"];
             var guild = json.ToDiscordObject<DiscordGuild>();
             foreach (var r in guild._roles.Values)
                 r._guild_id = guild.Id;
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
             return guild;
         }
 
 
 
         /// <summary>
         /// Modifies the guild community settings.
         /// </summary>
         /// <param name="guildId">The guild id.</param>
         /// <param name="features">The guild features.</param>
         /// <param name="rulesChannelId">The rules channel id.</param>
         /// <param name="publicUpdatesChannelId">The public updates channel id.</param>
         /// <param name="preferredLocale">The preferred locale.</param>
         /// <param name="description">The description.</param>
         /// <param name="defaultMessageNotifications">The default message notifications.</param>
         /// <param name="explicitContentFilter">The explicit content filter.</param>
         /// <param name="verificationLevel">The verification level.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordGuild> ModifyGuildCommunitySettingsAsync(ulong guildId, List<string> features, Optional<ulong?> rulesChannelId, Optional<ulong?> publicUpdatesChannelId, string preferredLocale, string description, DefaultMessageNotifications defaultMessageNotifications, ExplicitContentFilter explicitContentFilter, VerificationLevel verificationLevel, string reason)
         {
             var pld = new RestGuildCommunityModifyPayload
             {
                 VerificationLevel = verificationLevel,
                 DefaultMessageNotifications = defaultMessageNotifications,
                 ExplicitContentFilter = explicitContentFilter,
                 RulesChannelId = rulesChannelId,
                 PublicUpdatesChannelId = publicUpdatesChannelId,
                 PreferredLocale = preferredLocale,
                 Description = description ?? Optional.FromNoValue<string>(),
                 Features = features
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var rawMembers = (JArray)json["members"];
             var guild = json.ToDiscordObject<DiscordGuild>();
             foreach (var r in guild._roles.Values)
                 r._guild_id = guild.Id;
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
             return guild;
         }
 
         /// <summary>
         /// Gets the guild bans async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordBan>> GetGuildBansAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var bans_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordBan>>(res.Response).Select(xb =>
             {
                 if (!this.Discord.TryGetCachedUserInternal(xb.RawUser.Id, out var usr))
                 {
                     usr = new DiscordUser(xb.RawUser) { Discord = this.Discord };
                     usr = this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
                     {
                         old.Username = usr.Username;
                         old.Discriminator = usr.Discriminator;
                         old.AvatarHash = usr.AvatarHash;
                         return old;
                     });
                 }
 
                 xb.User = usr;
                 return xb;
             });
             var bans = new ReadOnlyCollection<DiscordBan>(new List<DiscordBan>(bans_raw));
 
             return bans;
         }
 
         /// <summary>
         /// Creates the guild ban async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="delete_message_days">The delete_message_days.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task CreateGuildBanAsync(ulong guild_id, ulong user_id, int delete_message_days, string reason)
         {
             if (delete_message_days < 0 || delete_message_days > 7)
                 throw new ArgumentException("Delete message days must be a number between 0 and 7.", nameof(delete_message_days));
 
             var urlparams = new Dictionary<string, string>
             {
                 ["delete_message_days"] = delete_message_days.ToString(CultureInfo.InvariantCulture)
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
         }
 
         /// <summary>
         /// Removes the guild ban async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task RemoveGuildBanAsync(ulong guild_id, ulong user_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Leaves the guild async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal Task LeaveGuildAsync(ulong guild_id)
         {
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}/:guild_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Adds the guild member async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="access_token">The access_token.</param>
         /// <param name="nick">The nick.</param>
         /// <param name="roles">The roles.</param>
         /// <param name="muted">If true, muted.</param>
         /// <param name="deafened">If true, deafened.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMember> AddGuildMemberAsync(ulong guild_id, ulong user_id, string access_token, string nick, IEnumerable<DiscordRole> roles, bool muted, bool deafened)
         {
             var pld = new RestGuildMemberAddPayload
             {
                 AccessToken = access_token,
                 Nickname = nick ?? "",
                 Roles = roles ?? new List<DiscordRole>(),
                 Deaf = deafened,
                 Mute = muted
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
             return new DiscordMember(tm) { Discord = this.Discord, _guild_id = guild_id };
         }
 
         /// <summary>
         /// Lists the guild members async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="limit">The limit.</param>
         /// <param name="after">The after.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<TransportMember>> ListGuildMembersAsync(ulong guild_id, int? limit, ulong? after)
         {
             var urlparams = new Dictionary<string, string>();
             if (limit != null && limit > 0)
                 urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
             if (after != null)
                 urlparams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var members_raw = JsonConvert.DeserializeObject<List<TransportMember>>(res.Response);
             return new ReadOnlyCollection<TransportMember>(members_raw);
         }
 
         /// <summary>
         /// Adds the guild member role async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="role_id">The role_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task AddGuildMemberRoleAsync(ulong guild_id, ulong user_id, ulong role_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { guild_id, user_id, role_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
         }
 
         /// <summary>
         /// Removes the guild member role async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="role_id">The role_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task RemoveGuildMemberRoleAsync(ulong guild_id, ulong user_id, ulong role_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, user_id, role_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Modifies the guild channel position async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="pld">The pld.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task ModifyGuildChannelPositionAsync(ulong guild_id, IEnumerable<RestGuildChannelReorderPayload> pld, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Modifies the guild channel parent async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="pld">The pld.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task ModifyGuildChannelParentAsync(ulong guild_id, IEnumerable<RestGuildChannelNewParentPayload> pld, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Detaches the guild channel parent async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="pld">The pld.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DetachGuildChannelParentAsync(ulong guild_id, IEnumerable<RestGuildChannelNoParentPayload> pld, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Modifies the guild role position async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="pld">The pld.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task ModifyGuildRolePositionAsync(ulong guild_id, IEnumerable<RestGuildRoleReorderPayload> pld, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Gets the audit logs async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="limit">The limit.</param>
         /// <param name="after">The after.</param>
         /// <param name="before">The before.</param>
         /// <param name="responsible">The responsible.</param>
         /// <param name="action_type">The action_type.</param>
         /// <returns>A Task.</returns>
         internal async Task<AuditLog> GetAuditLogsAsync(ulong guild_id, int limit, ulong? after, ulong? before, ulong? responsible, int? action_type)
         {
             var urlparams = new Dictionary<string, string>
             {
                 ["limit"] = limit.ToString(CultureInfo.InvariantCulture)
             };
             if (after != null)
                 urlparams["after"] = after?.ToString(CultureInfo.InvariantCulture);
             if (before != null)
                 urlparams["before"] = before?.ToString(CultureInfo.InvariantCulture);
             if (responsible != null)
                 urlparams["user_id"] = responsible?.ToString(CultureInfo.InvariantCulture);
             if (action_type != null)
                 urlparams["action_type"] = action_type?.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.AUDIT_LOGS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var audit_log_data_raw = JsonConvert.DeserializeObject<AuditLog>(res.Response);
 
             return audit_log_data_raw;
         }
 
         /// <summary>
         /// Gets the guild vanity url async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordInvite> GetGuildVanityUrlAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VANITY_URL}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var invite = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 
             return invite;
         }
 
         /// <summary>
         /// Gets the guild widget async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWidget> GetGuildWidgetAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET_JSON}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var rawChannels = (JArray)json["channels"];
 
             var ret = json.ToDiscordObject<DiscordWidget>();
             ret.Discord = this.Discord;
             ret.Guild = this.Discord.Guilds[guild_id];
 
             ret.Channels = ret.Guild == null
                 ? rawChannels.Select(r => new DiscordChannel
                 {
                     Id = (ulong)r["id"],
                     Name = r["name"].ToString(),
                     Position = (int)r["position"]
                 }).ToList()
                 : rawChannels.Select(r =>
                 {
                     var c = ret.Guild.GetChannel((ulong)r["id"]);
                     c.Position = (int)r["position"];
                     return c;
                 }).ToList();
 
             return ret;
         }
 
         /// <summary>
         /// Gets the guild widget settings async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWidgetSettings> GetGuildWidgetSettingsAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
             ret.Guild = this.Discord.Guilds[guild_id];
 
             return ret;
         }
 
         /// <summary>
         /// Modifies the guild widget settings async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="isEnabled">If true, is enabled.</param>
         /// <param name="channelId">The channel id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWidgetSettings> ModifyGuildWidgetSettingsAsync(ulong guild_id, bool? isEnabled, ulong? channelId, string reason)
         {
             var pld = new RestGuildWidgetSettingsPayload
             {
                 Enabled = isEnabled,
                 ChannelId = channelId
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
             ret.Guild = this.Discord.Guilds[guild_id];
 
             return ret;
         }
 
         /// <summary>
         /// Gets the guild templates async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordGuildTemplate>> GetGuildTemplatesAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var templates_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildTemplate>>(res.Response);
 
             return new ReadOnlyCollection<DiscordGuildTemplate>(new List<DiscordGuildTemplate>(templates_raw));
         }
 
         /// <summary>
         /// Creates the guild template async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="description">The description.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildTemplate> CreateGuildTemplateAsync(ulong guild_id, string name, string description)
         {
             var pld = new RestGuildTemplateCreateOrModifyPayload
             {
                 Name = name,
                 Description = description
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
             return ret;
         }
 
         /// <summary>
         /// Syncs the guild template async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="template_code">The template_code.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildTemplate> SyncGuildTemplateAsync(ulong guild_id, string template_code)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { guild_id, template_code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route).ConfigureAwait(false);
 
             var template_raw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
             return template_raw;
         }
 
         /// <summary>
         /// Modifies the guild template async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="template_code">The template_code.</param>
         /// <param name="name">The name.</param>
         /// <param name="description">The description.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildTemplate> ModifyGuildTemplateAsync(ulong guild_id, string template_code, string name, string description)
         {
             var pld = new RestGuildTemplateCreateOrModifyPayload
             {
                 Name = name,
                 Description = description
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, template_code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var template_raw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
             return template_raw;
         }
 
         /// <summary>
         /// Deletes the guild template async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="template_code">The template_code.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildTemplate> DeleteGuildTemplateAsync(ulong guild_id, string template_code)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, template_code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
             var template_raw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
             return template_raw;
         }
 
         /// <summary>
         /// Gets the guild membership screening form async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildMembershipScreening> GetGuildMembershipScreeningFormAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var screening_raw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
             return screening_raw;
         }
 
         /// <summary>
         /// Modifies the guild membership screening form async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="enabled">The enabled.</param>
         /// <param name="fields">The fields.</param>
         /// <param name="description">The description.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildMembershipScreening> ModifyGuildMembershipScreeningFormAsync(ulong guild_id, Optional<bool> enabled, Optional<DiscordGuildMembershipScreeningField[]> fields, Optional<string> description)
         {
             var pld = new RestGuildMembershipScreeningFormModifyPayload
             {
                 Enabled = enabled,
                 Description = description,
                 Fields = fields
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var screening_raw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
             return screening_raw;
         }
 
         /// <summary>
         /// Gets the guild welcome screen async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildWelcomeScreen> GetGuildWelcomeScreenAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
             return ret;
         }
 
         /// <summary>
         /// Modifies the guild welcome screen async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="enabled">The enabled.</param>
         /// <param name="welcomeChannels">The welcome channels.</param>
         /// <param name="description">The description.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildWelcomeScreen> ModifyGuildWelcomeScreenAsync(ulong guild_id, Optional<bool> enabled, Optional<IEnumerable<DiscordGuildWelcomeScreenChannel>> welcomeChannels, Optional<string> description)
         {
             var pld = new RestGuildWelcomeScreenModifyPayload
             {
                 Enabled = enabled,
                 WelcomeChannels = welcomeChannels,
                 Description = description
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
             return ret;
         }
 
         /// <summary>
         /// Updates the current user voice state async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="channelId">The channel id.</param>
         /// <param name="suppress">If true, suppress.</param>
         /// <param name="requestToSpeakTimestamp">The request to speak timestamp.</param>
         /// <returns>A Task.</returns>
         internal async Task UpdateCurrentUserVoiceStateAsync(ulong guild_id, ulong channelId, bool? suppress, DateTimeOffset? requestToSpeakTimestamp)
         {
             var pld = new RestGuildUpdateCurrentUserVoiceStatePayload
             {
                 ChannelId = channelId,
                 Suppress = suppress,
                 RequestToSpeakTimestamp = requestToSpeakTimestamp
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/@me";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Updates the user voice state async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="channelId">The channel id.</param>
         /// <param name="suppress">If true, suppress.</param>
         /// <returns>A Task.</returns>
         internal async Task UpdateUserVoiceStateAsync(ulong guild_id, ulong user_id, ulong channelId, bool? suppress)
         {
             var pld = new RestGuildUpdateUserVoiceStatePayload
             {
                 ChannelId = channelId,
                 Suppress = suppress
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
         }
         #endregion
 
         #region Guild Scheduled Events
 
         /// <summary>
         /// Creates a scheduled event.
         /// </summary>
         internal async Task<DiscordScheduledEvent> CreateGuildScheduledEventAsync(ulong guild_id, ulong? channel_id, DiscordScheduledEventEntityMetadata metadata, string name, DateTimeOffset scheduled_start_time, DateTimeOffset? scheduled_end_time, string description, ScheduledEventEntityType type, string reason = null)
         {
             var pld = new RestGuildScheduledEventCreatePayload
             {
                 ChannelId = channel_id,
                 EntityMetadata = metadata,
                 Name = name,
                 ScheduledStartTime = scheduled_start_time,
                 ScheduledEndTime = scheduled_end_time,
                 Description = description,
                 EntityType = type
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
             var scheduled_event = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
             var guild = this.Discord.Guilds[guild_id];
 
             scheduled_event.Discord = this.Discord;
 
             if (scheduled_event.Creator != null)
                 scheduled_event.Creator.Discord = this.Discord;
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildScheduledEventCreateEventAsync(scheduled_event, guild);
 
             return scheduled_event;
         }
 
         /// <summary>
         /// Modifies a scheduled event.
         /// </summary>
         internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventAsync(ulong guild_id, ulong scheduled_event_id, Optional<ulong?> channel_id, Optional<DiscordScheduledEventEntityMetadata> metadata, Optional<string> name, Optional<DateTimeOffset> scheduled_start_time, Optional<DateTimeOffset> scheduled_end_time, Optional<string> description, Optional<ScheduledEventEntityType> type, Optional<ScheduledEventStatus> status, string reason = null)
         {
             var pld = new RestGuildSheduledEventModifyPayload
             {
                 ChannelId = channel_id,
                 EntityMetadata = metadata,
                 Name = name,
                 ScheduledStartTime = scheduled_start_time,
                 ScheduledEndTime = scheduled_end_time,
                 Description = description,
                 EntityType = type,
                 Status = status
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, scheduled_event_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
             var scheduled_event = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
             var guild = this.Discord.Guilds[guild_id];
 
             scheduled_event.Discord = this.Discord;
 
             if (scheduled_event.Creator != null)
             {
                 scheduled_event.Creator.Discord = this.Discord;
                 this.Discord.UserCache.AddOrUpdate(scheduled_event.Creator.Id, scheduled_event.Creator, (id, old) =>
                 {
                     old.Username = scheduled_event.Creator.Username;
                     old.Discriminator = scheduled_event.Creator.Discriminator;
                     old.AvatarHash = scheduled_event.Creator.AvatarHash;
                     old.Flags = scheduled_event.Creator.Flags;
                     return old;
                 });
             }
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildScheduledEventUpdateEventAsync(scheduled_event, guild);
 
             return scheduled_event;
         }
 
         /// <summary>
         /// Modifies a scheduled event.
         /// </summary>
         internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventStatusAsync(ulong guild_id, ulong scheduled_event_id, ScheduledEventStatus status, string reason = null)
         {
             var pld = new RestGuildSheduledEventModifyPayload
             {
                 Status = status
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, scheduled_event_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
             var scheduled_event = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
             var guild = this.Discord.Guilds[guild_id];
 
             scheduled_event.Discord = this.Discord;
 
             if (scheduled_event.Creator != null)
             {
                 scheduled_event.Creator.Discord = this.Discord;
                 this.Discord.UserCache.AddOrUpdate(scheduled_event.Creator.Id, scheduled_event.Creator, (id, old) =>
                 {
                     old.Username = scheduled_event.Creator.Username;
                     old.Discriminator = scheduled_event.Creator.Discriminator;
                     old.AvatarHash = scheduled_event.Creator.AvatarHash;
                     old.Flags = scheduled_event.Creator.Flags;
                     return old;
                 });
             }
 
             if (this.Discord is DiscordClient dc)
                 await dc.OnGuildScheduledEventUpdateEventAsync(scheduled_event, guild);
 
             return scheduled_event;
         }
 
         /// <summary>
         /// Gets a scheduled event.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="scheduled_event_id">The event id.</param>
         /// <param name="with_user_count">Whether to include user count.</param>
         internal async Task<DiscordScheduledEvent> GetGuildScheduledEventAsync(ulong guild_id, ulong scheduled_event_id, bool? with_user_count)
         {
             var urlparams = new Dictionary<string, string>();
             if (with_user_count.HasValue)
                 urlparams["with_user_count"] = with_user_count?.ToString();
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id, scheduled_event_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var scheduled_event = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
             var guild = this.Discord.Guilds[guild_id];
 
             scheduled_event.Discord = this.Discord;
 
             if (scheduled_event.Creator != null)
             {
                 scheduled_event.Creator.Discord = this.Discord;
                 this.Discord.UserCache.AddOrUpdate(scheduled_event.Creator.Id, scheduled_event.Creator, (id, old) =>
                 {
                     old.Username = scheduled_event.Creator.Username;
                     old.Discriminator = scheduled_event.Creator.Discriminator;
                     old.AvatarHash = scheduled_event.Creator.AvatarHash;
                     old.Flags = scheduled_event.Creator.Flags;
                     return old;
                 });
             }
 
             return scheduled_event;
         }
 
         /// <summary>
         /// Gets the guilds scheduled events.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="with_user_count">Whether to include the count of users subscribed to the scheduled event.</param>
         internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> ListGuildScheduledEventsAsync(ulong guild_id, bool? with_user_count)
         {
             var urlparams = new Dictionary<string, string>();
             if (with_user_count.HasValue)
                 urlparams["with_user_count"] = with_user_count?.ToString();
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var events = new Dictionary<ulong, DiscordScheduledEvent>();
             var events_raw = JsonConvert.DeserializeObject<List<DiscordScheduledEvent>>(res.Response);
             var guild = this.Discord.Guilds[guild_id];
 
             foreach (var ev in events_raw)
             {
                 ev.Discord = this.Discord;
                 if(ev.Creator != null)
                 {
                     ev.Creator.Discord = this.Discord;
                     this.Discord.UserCache.AddOrUpdate(ev.Creator.Id, ev.Creator, (id, old) =>
                     {
                         old.Username = ev.Creator.Username;
                         old.Discriminator = ev.Creator.Discriminator;
                         old.AvatarHash = ev.Creator.AvatarHash;
                         old.Flags = ev.Creator.Flags;
                         return old;
                     });
                 }
 
                 events.Add(ev.Id, ev);
             }
 
             return new ReadOnlyDictionary<ulong, DiscordScheduledEvent>(new Dictionary<ulong, DiscordScheduledEvent>(events));
         }
 
         /// <summary>
         /// Deletes a guild sheduled event.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="scheduled_event_id">The sheduled event id.</param>
         /// <param name="reason">The reason.</param>
         internal Task DeleteGuildScheduledEventAsync(ulong guild_id, ulong scheduled_event_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, scheduled_event_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Gets the users who RSVP'd to a sheduled event.
         /// Optional with member objects.
         /// This endpoint is paginated.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="scheduled_event_id">The sheduled event id.</param>
         /// <param name="limit">The limit how many users to receive from the event.</param>
         /// <param name="before">Get results before the given id.</param>
         /// <param name="after">Get results after the given id.</param>
         /// <param name="with_member">Wether to include guild member data. attaches guild_member property to the user object.</param>
         internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEventUser>> GetGuildScheduledEventRSPVUsersAsync(ulong guild_id, ulong scheduled_event_id, int? limit, ulong? before, ulong? after, bool? with_member)
         {
             var urlparams = new Dictionary<string, string>();
             if (limit != null && limit > 0)
                 urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
             if (before != null)
                 urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
             if (after != null)
                 urlparams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
             if (with_member != null)
                 urlparams["with_member"] = with_member.Value.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id{Endpoints.USERS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id, scheduled_event_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var rspv_users = JsonConvert.DeserializeObject<IEnumerable<DiscordScheduledEventUser>>(res.Response);
             Dictionary<ulong, DiscordScheduledEventUser> rspv = new();
 
             foreach (var rspv_user in rspv_users)
             {
 
                 rspv_user.Discord = this.Discord;
                 rspv_user.GuildId = guild_id;
 
                 rspv_user.User.Discord = this.Discord;
                 rspv_user.User = this.Discord.UserCache.AddOrUpdate(rspv_user.User.Id, rspv_user.User, (id, old) =>
                 {
                     old.Username = rspv_user.User.Username;
                     old.Discriminator = rspv_user.User.Discriminator;
                     old.AvatarHash = rspv_user.User.AvatarHash;
                     old.BannerHash = rspv_user.User.BannerHash;
                     old._bannerColor = rspv_user.User._bannerColor;
                     return old;
                 });
 
                 /*if (with_member.HasValue && with_member.Value && rspv_user.Member != null)
                 {
                     rspv_user.Member.Discord = this.Discord;
                 }*/
 
                 rspv.Add(rspv_user.User.Id, rspv_user);
             }
 
             return new ReadOnlyDictionary<ulong, DiscordScheduledEventUser>(new Dictionary<ulong, DiscordScheduledEventUser>(rspv));
         }
         #endregion
 
         #region Channel
         /// <summary>
         /// Creates the guild channel async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="type">The type.</param>
         /// <param name="parent">The parent.</param>
         /// <param name="topic">The topic.</param>
         /// <param name="bitrate">The bitrate.</param>
         /// <param name="user_limit">The user_limit.</param>
         /// <param name="overwrites">The overwrites.</param>
         /// <param name="nsfw">If true, nsfw.</param>
         /// <param name="perUserRateLimit">The per user rate limit.</param>
         /// <param name="qualityMode">The quality mode.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordChannel> CreateGuildChannelAsync(ulong guild_id, string name, ChannelType type, ulong? parent, Optional<string> topic, int? bitrate, int? user_limit, IEnumerable<DiscordOverwriteBuilder> overwrites, bool? nsfw, Optional<int?> perUserRateLimit, VideoQualityMode? qualityMode, string reason)
         {
             var restoverwrites = new List<DiscordRestOverwrite>();
             if (overwrites != null)
                 foreach (var ow in overwrites)
                     restoverwrites.Add(ow.Build());
 
             var pld = new RestChannelCreatePayload
             {
                 Name = name,
                 Type = type,
                 Parent = parent,
                 Topic = topic,
                 Bitrate = bitrate,
                 UserLimit = user_limit,
                 PermissionOverwrites = restoverwrites,
                 Nsfw = nsfw,
                 PerUserRateLimit = perUserRateLimit,
                 QualityMode = qualityMode
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
             ret.Discord = this.Discord;
             foreach (var xo in ret._permissionOverwrites)
             {
                 xo.Discord = this.Discord;
                 xo._channel_id = ret.Id;
             }
 
             return ret;
         }
 
         /// <summary>
         /// Modifies the channel async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="position">The position.</param>
         /// <param name="topic">The topic.</param>
         /// <param name="nsfw">If true, nsfw.</param>
         /// <param name="parent">The parent.</param>
         /// <param name="bitrate">The bitrate.</param>
         /// <param name="user_limit">The user_limit.</param>
         /// <param name="perUserRateLimit">The per user rate limit.</param>
         /// <param name="rtcRegion">The rtc region.</param>
         /// <param name="qualityMode">The quality mode.</param>
         /// <param name="autoArchiveDuration">The default auto archive duration.</param>
         /// <param name="type">The type.</param>
         /// <param name="permissionOverwrites">The permission overwrites.</param>
         /// <param name="bannerb64">The banner.</param>
         /// <param name="reason">The reason.</param>
         internal Task ModifyChannelAsync(ulong channel_id, string name, int? position, Optional<string> topic, bool? nsfw, Optional<ulong?> parent, int? bitrate, int? user_limit, Optional<int?> perUserRateLimit, Optional<string> rtcRegion, VideoQualityMode? qualityMode, ThreadAutoArchiveDuration? autoArchiveDuration, Optional<ChannelType> type, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, Optional<string> bannerb64, string reason)
         {
 
             List<DiscordRestOverwrite> restoverwrites = null;
             if (permissionOverwrites != null)
             {
                 restoverwrites = new List<DiscordRestOverwrite>();
                 foreach (var ow in permissionOverwrites)
                     restoverwrites.Add(ow.Build());
             }
 
             var pld = new RestChannelModifyPayload
             {
                 Name = name,
                 Position = position,
                 Topic = topic,
                 Nsfw = nsfw,
                 Parent = parent,
                 Bitrate = bitrate,
                 UserLimit = user_limit,
                 PerUserRateLimit = perUserRateLimit,
                 RtcRegion = rtcRegion,
                 QualityMode = qualityMode,
                 DefaultAutoArchiveDuration = autoArchiveDuration,
                 Type = type,
                 PermissionOverwrites = restoverwrites,
                 BannerBase64 = bannerb64
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Gets the channel async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordChannel> GetChannelAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
             ret.Discord = this.Discord;
             foreach (var xo in ret._permissionOverwrites)
             {
                 xo.Discord = this.Discord;
                 xo._channel_id = ret.Id;
             }
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the channel async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteChannelAsync(ulong channel_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Gets the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> GetMessageAsync(ulong channel_id, ulong message_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
             return ret;
         }
 
         /// <summary>
         /// Creates the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="content">The content.</param>
         /// <param name="embeds">The embeds.</param>
         /// <param name="sticker">The sticker.</param>
         /// <param name="replyMessageId">The reply message id.</param>
         /// <param name="mentionReply">If true, mention reply.</param>
         /// <param name="failOnInvalidReply">If true, fail on invalid reply.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> CreateMessageAsync(ulong channel_id, string content, IEnumerable<DiscordEmbed> embeds, DiscordSticker sticker, ulong? replyMessageId, bool mentionReply, bool failOnInvalidReply)
         {
             if (content != null && content.Length > 2000)
                 throw new ArgumentException("Message content length cannot exceed 2000 characters.");
 
             if (!embeds?.Any() ?? true)
             {
                 if (content == null && sticker == null)
                     throw new ArgumentException("You must specify message content, a sticker or an embed.");
                 if (content.Length == 0)
                     throw new ArgumentException("Message content must not be empty.");
             }
 
             if (embeds != null)
                 foreach (var embed in embeds)
                     if (embed.Timestamp != null)
                         embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
             var pld = new RestChannelMessageCreatePayload
             {
                 HasContent = content != null,
                 Content = content,
                 StickersIds = sticker is null ? Array.Empty<ulong>() : new[] {sticker.Id},
                 IsTTS = false,
                 HasEmbed = embeds?.Any() ?? false,
                 Embeds = embeds
             };
 
             if (replyMessageId != null)
                 pld.MessageReference = new InternalDiscordMessageReference { MessageId = replyMessageId, FailIfNotExists = failOnInvalidReply };
 
             if (replyMessageId != null)
                 pld.Mentions = new DiscordMentions(Mentions.All, true, mentionReply);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
             return ret;
         }
 
         /// <summary>
         /// Creates the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="builder">The builder.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> CreateMessageAsync(ulong channel_id, DiscordMessageBuilder builder)
         {
             builder.Validate();
 
             if (builder.Embeds != null)
                 foreach (var embed in builder.Embeds)
                     if (embed?.Timestamp != null)
                         embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
             var pld = new RestChannelMessageCreatePayload
             {
                 HasContent = builder.Content != null,
                 Content = builder.Content,
                 StickersIds = builder.Sticker is null ? Array.Empty<ulong>() : new[] {builder.Sticker.Id},
                 IsTTS = builder.IsTTS,
                 HasEmbed = builder.Embeds != null,
                 Embeds = builder.Embeds,
                 Components = builder.Components
             };
 
             if (builder.ReplyId != null)
                 pld.MessageReference = new InternalDiscordMessageReference { MessageId = builder.ReplyId, FailIfNotExists = builder.FailOnInvalidReply };
 
             pld.Mentions = new DiscordMentions(builder.Mentions ?? Mentions.All, builder.Mentions?.Any() ?? false, builder.MentionOnReply);
 
             if (builder.Files.Count == 0)
             {
                 var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
                 var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
                 var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
                 var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
                 var ret = this.PrepareMessage(JObject.Parse(res.Response));
                 return ret;
             }
             else
             {
                 ulong file_id = 0;
                 List<DiscordAttachment> attachments = new(builder.Files.Count);
                 foreach(var file in builder.Files)
                 {
                     DiscordAttachment att = new()
                     {
                         Id = file_id,
                         Discord = this.Discord,
                         Description = file.Description,
                         FileName = file.FileName
                     };
                     attachments.Add(att);
                     file_id++;
                 }
                 pld.Attachments = attachments;
 
-                this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
-
                 var values = new Dictionary<string, string>
                 {
                     ["payload_json"] = DiscordJson.SerializeObject(pld)
                 };
 
                 var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
                 var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
                 var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
-                try
-                {
+                var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 
-                    var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
-
-                    var ret = this.PrepareMessage(JObject.Parse(res.Response));
-
-                    foreach (var file in builder._files.Where(x => x.ResetPositionTo.HasValue))
-                    {
-                        file.Stream.Position = file.ResetPositionTo.Value;
-                    }
+                var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
-                    return ret;
-                } catch(BadRequestException ex)
+                foreach (var file in builder._files.Where(x => x.ResetPositionTo.HasValue))
                 {
-                    this.Discord.Logger.LogError(ex.Message);
-                    this.Discord.Logger.LogError(ex.StackTrace);
-                    this.Discord.Logger.LogDebug(ex.WebResponse.Response);
-                    return null;
+                    file.Stream.Position = file.ResetPositionTo.Value;
                 }
+
+                return ret;
             }
         }
 
         /// <summary>
         /// Gets the guild channels async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordChannel>> GetGuildChannelsAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var channels_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordChannel>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
             foreach (var ret in channels_raw)
                 foreach (var xo in ret._permissionOverwrites)
                 {
                     xo.Discord = this.Discord;
                     xo._channel_id = ret.Id;
                 }
 
             return new ReadOnlyCollection<DiscordChannel>(new List<DiscordChannel>(channels_raw));
         }
 
         /// <summary>
         /// Creates the stage instance async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="topic">The topic.</param>
         /// <param name="send_start_notification">Whether everyone should be notified about the stage.</param>
         /// <param name="privacy_level">The privacy_level.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordStageInstance> CreateStageInstanceAsync(ulong channel_id, string topic, bool send_start_notification, StagePrivacyLevel privacy_level, string reason)
         {
             var pld = new RestStageInstanceCreatePayload
             {
                 ChannelId = channel_id,
                 Topic = topic,
                 PrivacyLevel = privacy_level,
                 SendStartNotification = send_start_notification
             };
 
             var route = $"{Endpoints.STAGE_INSTANCES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
             return stageInstance;
         }
 
         /// <summary>
         /// Gets the stage instance async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         internal async Task<DiscordStageInstance> GetStageInstanceAsync(ulong channel_id)
         {
             var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
             return stageInstance;
         }
 
         /// <summary>
         /// Modifies the stage instance async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="topic">The topic.</param>
         /// <param name="privacy_level">The privacy_level.</param>
         /// <param name="reason">The reason.</param>
         internal Task ModifyStageInstanceAsync(ulong channel_id, Optional<string> topic, Optional<StagePrivacyLevel> privacy_level, string reason)
         {
             var pld = new RestStageInstanceModifyPayload
             {
                 Topic = topic,
                 PrivacyLevel = privacy_level
             };
 
             var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { channel_id }, out var path);
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Deletes the stage instance async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="reason">The reason.</param>
         internal Task DeleteStageInstanceAsync(ulong channel_id, string reason)
         {
             var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id }, out var path);
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Gets the channel messages async.
         /// </summary>
         /// <param name="channel_id">The channel id.</param>
         /// <param name="limit">The limit.</param>
         /// <param name="before">The before.</param>
         /// <param name="after">The after.</param>
         /// <param name="around">The around.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordMessage>> GetChannelMessagesAsync(ulong channel_id, int limit, ulong? before, ulong? after, ulong? around)
         {
             var urlparams = new Dictionary<string, string>();
             if (around != null)
                 urlparams["around"] = around?.ToString(CultureInfo.InvariantCulture);
             if (before != null)
                 urlparams["before"] = before?.ToString(CultureInfo.InvariantCulture);
             if (after != null)
                 urlparams["after"] = after?.ToString(CultureInfo.InvariantCulture);
             if (limit > 0)
                 urlparams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var msgs_raw = JArray.Parse(res.Response);
             var msgs = new List<DiscordMessage>();
             foreach (var xj in msgs_raw)
                 msgs.Add(this.PrepareMessage(xj));
 
             return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
         }
 
         /// <summary>
         /// Gets the channel message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> GetChannelMessageAsync(ulong channel_id, ulong message_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
             return ret;
         }
 
         /// <summary>
         /// Edits the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="content">The content.</param>
         /// <param name="embeds">The embeds.</param>
         /// <param name="mentions">The mentions.</param>
         /// <param name="components">The components.</param>
         /// <param name="suppress_embed">The suppress_embed.</param>
         /// <param name="files">The files.</param>
+        /// <param name="attachments">The attachments to keep.</param>
         /// <returns>A Task.</returns>
-        internal async Task<DiscordMessage> EditMessageAsync(ulong channel_id, ulong message_id, Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds, IEnumerable<IMention> mentions, IReadOnlyList<DiscordActionRowComponent> components, Optional<bool> suppress_embed, IReadOnlyCollection<DiscordMessageFile> files)
+        internal async Task<DiscordMessage> EditMessageAsync(ulong channel_id, ulong message_id, Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds, IEnumerable<IMention> mentions, IReadOnlyList<DiscordActionRowComponent> components, Optional<bool> suppress_embed, IReadOnlyCollection<DiscordMessageFile> files, Optional<IEnumerable<DiscordAttachment>> attachments)
         {
             if (embeds.HasValue && embeds.Value != null)
                 foreach (var embed in embeds.Value)
                     if (embed.Timestamp != null)
                         embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
             var pld = new RestChannelMessageEditPayload
             {
                 HasContent = content.HasValue,
                 Content = content.HasValue ? (string)content : null,
                 HasEmbed = embeds.HasValue && (embeds.Value?.Any() ?? false),
                 Embeds = embeds.HasValue && (embeds.Value?.Any() ?? false) ? embeds.Value : null,
-                Components = components,
+                Components = components ?? null,
                 Flags = suppress_embed.HasValue ? (bool)suppress_embed ? MessageFlags.SuppressedEmbeds : null : null
             };
 
             pld.Mentions = new DiscordMentions(mentions ?? Mentions.None, false, mentions?.OfType<RepliedUserMention>().Any() ?? false);
 
-            var values = new Dictionary<string, string>
+            if (files?.Count > 0)
             {
-                ["payload_json"] = DiscordJson.SerializeObject(pld)
-            };
+                ulong file_id = 0;
+                List<DiscordAttachment> attachments_new = new();
+                foreach (var file in files)
+                {
+                    DiscordAttachment att = new()
+                    {
+                        Id = file_id,
+                        Discord = this.Discord,
+                        Description = file.Description,
+                        FileName = file.FileName
+                    };
+                    attachments_new.Add(att);
+                    file_id++;
+                }
+                if (attachments.HasValue && attachments.Value.Any())
+                    attachments_new.AddRange(attachments.Value);
 
-            var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
-            var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { channel_id, message_id }, out var path);
+                pld.Attachments = attachments_new;
 
-            var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
-            var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: files).ConfigureAwait(false);
+                var values = new Dictionary<string, string>
+                {
+                    ["payload_json"] = DiscordJson.SerializeObject(pld)
+                };
 
-            var ret = this.PrepareMessage(JObject.Parse(res.Response));
+                var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
+                var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { channel_id, message_id }, out var path);
 
-            foreach (var file in files.Where(x => x.ResetPositionTo.HasValue))
-            {
-                file.Stream.Position = file.ResetPositionTo.Value;
+                var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+                var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: files).ConfigureAwait(false);
+
+                var ret = this.PrepareMessage(JObject.Parse(res.Response));
+
+                foreach (var file in files.Where(x => x.ResetPositionTo.HasValue))
+                {
+                    file.Stream.Position = file.ResetPositionTo.Value;
+                }
+
+                return ret;
             }
+            else
+            {
+                pld.Attachments = attachments.HasValue ? attachments.Value : null;
 
-            return ret;
+                var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
+                var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { channel_id, message_id }, out var path);
+
+                var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+                var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
+
+                var ret = this.PrepareMessage(JObject.Parse(res.Response));
+
+                return ret;
+            }            
         }
 
         /// <summary>
         /// Deletes the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteMessageAsync(ulong channel_id, ulong message_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Deletes the messages async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_ids">The message_ids.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteMessagesAsync(ulong channel_id, IEnumerable<ulong> message_ids, string reason)
         {
             var pld = new RestChannelMessageBulkDeletePayload
             {
                 Messages = message_ids
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}{Endpoints.BULK_DELETE}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Gets the channel invites async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordInvite>> GetChannelInvitesAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var invites_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
             return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invites_raw));
         }
 
         /// <summary>
         /// Creates the channel invite async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="max_age">The max_age.</param>
         /// <param name="max_uses">The max_uses.</param>
         /// <param name="target_type">The target_type.</param>
         /// <param name="target_application">The target_application.</param>
         /// <param name="target_user">The target_user.</param>
         /// <param name="temporary">If true, temporary.</param>
         /// <param name="unique">If true, unique.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordInvite> CreateChannelInviteAsync(ulong channel_id, int max_age, int max_uses, TargetType? target_type, TargetActivity? target_application, ulong? target_user, bool temporary, bool unique, string reason)
         {
             var pld = new RestChannelInviteCreatePayload
             {
                 MaxAge = max_age,
                 MaxUses = max_uses,
                 TargetType = target_type,
                 TargetApplication = target_application,
                 TargetUserId = target_user,
                 Temporary = temporary,
                 Unique = unique
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the channel permission async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="overwrite_id">The overwrite_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteChannelPermissionAsync(ulong channel_id, ulong overwrite_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, overwrite_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Edits the channel permissions async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="overwrite_id">The overwrite_id.</param>
         /// <param name="allow">The allow.</param>
         /// <param name="deny">The deny.</param>
         /// <param name="type">The type.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task EditChannelPermissionsAsync(ulong channel_id, ulong overwrite_id, Permissions allow, Permissions deny, string type, string reason)
         {
             var pld = new RestChannelPermissionEditPayload
             {
                 Type = type,
                 Allow = allow & PermissionMethods.FULL_PERMS,
                 Deny = deny & PermissionMethods.FULL_PERMS
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id, overwrite_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Triggers the typing async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <returns>A Task.</returns>
         internal Task TriggerTypingAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TYPING}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
         }
 
         /// <summary>
         /// Gets the pinned messages async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var msgs_raw = JArray.Parse(res.Response);
             var msgs = new List<DiscordMessage>();
             foreach (var xj in msgs_raw)
                 msgs.Add(this.PrepareMessage(xj));
 
             return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
         }
 
         /// <summary>
         /// Pins the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal Task PinMessageAsync(ulong channel_id, ulong message_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
         }
 
         /// <summary>
         /// Unpins the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal Task UnpinMessageAsync(ulong channel_id, ulong message_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Adds the group dm recipient async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="access_token">The access_token.</param>
         /// <param name="nickname">The nickname.</param>
         /// <returns>A Task.</returns>
         internal Task AddGroupDmRecipientAsync(ulong channel_id, ulong user_id, string access_token, string nickname)
         {
             var pld = new RestChannelGroupDmRecipientAddPayload
             {
                 AccessToken = access_token,
                 Nickname = nickname
             };
 
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Removes the group dm recipient async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <returns>A Task.</returns>
         internal Task RemoveGroupDmRecipientAsync(ulong channel_id, ulong user_id)
         {
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Creates the group dm async.
         /// </summary>
         /// <param name="access_tokens">The access_tokens.</param>
         /// <param name="nicks">The nicks.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordDmChannel> CreateGroupDmAsync(IEnumerable<string> access_tokens, IDictionary<ulong, string> nicks)
         {
             var pld = new RestUserGroupDmCreatePayload
             {
                 AccessTokens = access_tokens,
                 Nicknames = nicks
             };
 
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Creates the dm async.
         /// </summary>
         /// <param name="recipient_id">The recipient_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordDmChannel> CreateDmAsync(ulong recipient_id)
         {
             var pld = new RestUserDmCreatePayload
             {
                 Recipient = recipient_id
             };
 
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Follows the channel async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="webhook_channel_id">The webhook_channel_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordFollowedChannel> FollowChannelAsync(ulong channel_id, ulong webhook_channel_id)
         {
             var pld = new FollowedChannelAddPayload
             {
                 WebhookChannelId = webhook_channel_id
             };
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.FOLLOWERS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             return JsonConvert.DeserializeObject<DiscordFollowedChannel>(response.Response);
         }
 
         /// <summary>
         /// Crossposts the message async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> CrosspostMessageAsync(ulong channel_id, ulong message_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.CROSSPOST}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route).ConfigureAwait(false);
             return JsonConvert.DeserializeObject<DiscordMessage>(response.Response);
         }
 
         #endregion
 
         #region Member
         /// <summary>
         /// Gets the current user async.
         /// </summary>
         /// <returns>A Task.</returns>
         internal Task<DiscordUser> GetCurrentUserAsync()
             => this.GetUserAsync("@me");
 
         /// <summary>
         /// Gets the user async.
         /// </summary>
         /// <param name="user_id">The user_id.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordUser> GetUserAsync(ulong user_id)
             => this.GetUserAsync(user_id.ToString(CultureInfo.InvariantCulture));
 
         /// <summary>
         /// Gets the user async.
         /// </summary>
         /// <param name="user_id">The user_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordUser> GetUserAsync(string user_id)
         {
             var route = $"{Endpoints.USERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var user_raw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
             var duser = new DiscordUser(user_raw) { Discord = this.Discord };
 
             return duser;
         }
 
         /// <summary>
         /// Gets the guild member async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMember> GetGuildMemberAsync(ulong guild_id, ulong user_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
             var usr = new DiscordUser(tm.User) { Discord = this.Discord };
             usr = this.Discord.UserCache.AddOrUpdate(tm.User.Id, usr, (id, old) =>
             {
                 old.Username = usr.Username;
                 old.Discriminator = usr.Discriminator;
                 old.AvatarHash = usr.AvatarHash;
                 return old;
             });
 
             return new DiscordMember(tm)
             {
                 Discord = this.Discord,
                 _guild_id = guild_id
             };
         }
 
         /// <summary>
         /// Removes the guild member async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task RemoveGuildMemberAsync(ulong guild_id, ulong user_id, string reason)
         {
             var urlparams = new Dictionary<string, string>();
             if (reason != null)
                 urlparams["reason"] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Modifies the current user async.
         /// </summary>
         /// <param name="username">The username.</param>
         /// <param name="base64_avatar">The base64_avatar.</param>
         /// <returns>A Task.</returns>
         internal async Task<TransportUser> ModifyCurrentUserAsync(string username, Optional<string> base64_avatar)
         {
             var pld = new RestUserUpdateCurrentPayload
             {
                 Username = username,
                 AvatarBase64 = base64_avatar.HasValue ? base64_avatar.Value : null,
                 AvatarSet = base64_avatar.HasValue
             };
 
             var route = $"{Endpoints.USERS}{Endpoints.ME}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var user_raw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 
             return user_raw;
         }
 
         /// <summary>
         /// Gets the current user guilds async.
         /// </summary>
         /// <param name="limit">The limit.</param>
         /// <param name="before">The before.</param>
         /// <param name="after">The after.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordGuild>> GetCurrentUserGuildsAsync(int limit = 100, ulong? before = null, ulong? after = null)
         {
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}";
 
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
             var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration)
                 .AddParameter($"limit", limit.ToString(CultureInfo.InvariantCulture));
 
             if (before != null)
                 url.AddParameter("before", before.Value.ToString(CultureInfo.InvariantCulture));
             if (after != null)
                 url.AddParameter("after", after.Value.ToString(CultureInfo.InvariantCulture));
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url.Build(), RestRequestMethod.GET, route).ConfigureAwait(false);
 
             if (this.Discord is DiscordClient)
             {
                 var guilds_raw = JsonConvert.DeserializeObject<IEnumerable<RestUserGuild>>(res.Response);
                 var glds = guilds_raw.Select(xug => (this.Discord as DiscordClient)?._guilds[xug.Id]);
                 return new ReadOnlyCollection<DiscordGuild>(new List<DiscordGuild>(glds));
             }
             else
             {
                 return new ReadOnlyCollection<DiscordGuild>(JsonConvert.DeserializeObject<List<DiscordGuild>>(res.Response));
             }
         }
 
         /// <summary>
         /// Modifies the guild member async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="nick">The nick.</param>
         /// <param name="role_ids">The role_ids.</param>
         /// <param name="mute">The mute.</param>
         /// <param name="deaf">The deaf.</param>
         /// <param name="voice_channel_id">The voice_channel_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task ModifyGuildMemberAsync(ulong guild_id, ulong user_id, Optional<string> nick,
             Optional<IEnumerable<ulong>> role_ids, Optional<bool> mute, Optional<bool> deaf,
             Optional<ulong?> voice_channel_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var pld = new RestGuildMemberModifyPayload
             {
                 Nickname = nick,
                 RoleIds = role_ids,
                 Deafen = deaf,
                 Mute = mute,
                 VoiceChannelId = voice_channel_id
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Modifies the time out of a guild member.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="until">Datetime offset.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task ModifyTimeoutAsync(ulong guild_id, ulong user_id, DateTimeOffset? until, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var pld = new RestGuildMemberTimeoutModifyPayload
             {
                 CommunicationDisabledUntil = until
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Modifies the current member nickname async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="nick">The nick.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task ModifyCurrentMemberNicknameAsync(ulong guild_id, string nick, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var pld = new RestGuildMemberModifyPayload
             {
                 Nickname = nick
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.ME}{Endpoints.NICK}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
         }
         #endregion
 
         #region Roles
         /// <summary>
         /// Gets the guild roles async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordRole>> GetGuildRolesAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var roles_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordRole>>(res.Response).Select(xr => { xr.Discord = this.Discord; xr._guild_id = guild_id; return xr; });
 
             return new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(roles_raw));
         }
 
         /// <summary>
         /// Gets the guild async.
         /// </summary>
         /// <param name="guildId">The guild id.</param>
         /// <param name="with_counts">If true, with_counts.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuild> GetGuildAsync(ulong guildId, bool? with_counts)
         {
             var urlparams = new Dictionary<string, string>();
             if (with_counts.HasValue)
                 urlparams["with_counts"] = with_counts?.ToString();
 
             var route = $"{Endpoints.GUILDS}/:guild_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id = guildId }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, urlparams).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var rawMembers = (JArray)json["members"];
             var guildRest = json.ToDiscordObject<DiscordGuild>();
             foreach (var r in guildRest._roles.Values)
                 r._guild_id = guildRest.Id;
 
             if (this.Discord is DiscordClient dc)
             {
                 await dc.OnGuildUpdateEventAsync(guildRest, rawMembers).ConfigureAwait(false);
                 return dc._guilds[guildRest.Id];
             }
             else
             {
                 guildRest.Discord = this.Discord;
                 return guildRest;
             }
         }
 
         /// <summary>
         /// Modifies the guild role async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="role_id">The role_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="permissions">The permissions.</param>
         /// <param name="color">The color.</param>
         /// <param name="hoist">If true, hoist.</param>
         /// <param name="mentionable">If true, mentionable.</param>
         /// <param name="iconb64">The icon.</param>
         /// <param name="emoji">The unicode emoji icon.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordRole> ModifyGuildRoleAsync(ulong guild_id, ulong role_id, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, Optional<string> iconb64, Optional<string> emoji, string reason)
         {
             var pld = new RestGuildRolePayload
             {
                 Name = name,
                 Permissions = permissions & PermissionMethods.FULL_PERMS,
                 Color = color,
                 Hoist = hoist,
                 Mentionable = mentionable,
             };
 
             if (emoji.HasValue && !iconb64.HasValue)
                 pld.UnicodeEmoji = emoji;
 
             if (emoji.HasValue && iconb64.HasValue)
             {
                 pld.IconBase64 = null;
                 pld.UnicodeEmoji = emoji;
             }
 
             if (iconb64.HasValue)
                 pld.IconBase64 = iconb64;
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, role_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
             ret.Discord = this.Discord;
             ret._guild_id = guild_id;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the role async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="role_id">The role_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteRoleAsync(ulong guild_id, ulong role_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, role_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Creates the guild role async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="permissions">The permissions.</param>
         /// <param name="color">The color.</param>
         /// <param name="hoist">If true, hoist.</param>
         /// <param name="mentionable">If true, mentionable.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordRole> CreateGuildRoleAsync(ulong guild_id, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, string reason)
         {
             var pld = new RestGuildRolePayload
             {
                 Name = name,
                 Permissions = permissions & PermissionMethods.FULL_PERMS,
                 Color = color,
                 Hoist = hoist,
                 Mentionable = mentionable
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
             ret.Discord = this.Discord;
             ret._guild_id = guild_id;
 
             return ret;
         }
         #endregion
 
         #region Prune
         /// <summary>
         /// Gets the guild prune count async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="days">The days.</param>
         /// <param name="include_roles">The include_roles.</param>
         /// <returns>A Task.</returns>
         internal async Task<int> GetGuildPruneCountAsync(ulong guild_id, int days, IEnumerable<ulong> include_roles)
         {
             if (days < 0 || days > 30)
                 throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
             var urlparams = new Dictionary<string, string>
             {
                 ["days"] = days.ToString(CultureInfo.InvariantCulture)
             };
 
             var sb = new StringBuilder();
 
             if (include_roles != null)
             {
                 var roleArray = include_roles.ToArray();
                 var roleArrayCount = roleArray.Count();
 
                 for (var i = 0; i < roleArrayCount; i++)
                     sb.Append($"&include_roles={roleArray[i]}");
             }
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
             var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlparams)}{sb}", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
             return pruned.Pruned.Value;
         }
 
         /// <summary>
         /// Begins the guild prune async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="days">The days.</param>
         /// <param name="compute_prune_count">If true, compute_prune_count.</param>
         /// <param name="include_roles">The include_roles.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<int?> BeginGuildPruneAsync(ulong guild_id, int days, bool compute_prune_count, IEnumerable<ulong> include_roles, string reason)
         {
             if (days < 0 || days > 30)
                 throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
             var urlparams = new Dictionary<string, string>
             {
                 ["days"] = days.ToString(CultureInfo.InvariantCulture),
                 ["compute_prune_count"] = compute_prune_count.ToString()
             };
 
             var sb = new StringBuilder();
 
             if (include_roles != null)
             {
                 var roleArray = include_roles.ToArray();
                 var roleArrayCount = roleArray.Count();
 
                 for (var i = 0; i < roleArrayCount; i++)
                     sb.Append($"&include_roles={roleArray[i]}");
             }
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlparams)}{sb}", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers).ConfigureAwait(false);
 
             var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
             return pruned.Pruned;
         }
         #endregion
 
         #region GuildVarious
         /// <summary>
         /// Gets the template async.
         /// </summary>
         /// <param name="code">The code.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildTemplate> GetTemplateAsync(string code)
         {
             var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var templates_raw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
             return templates_raw;
         }
 
         /// <summary>
         /// Gets the guild integrations async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordIntegration>> GetGuildIntegrationsAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var integrations_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordIntegration>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
             return new ReadOnlyCollection<DiscordIntegration>(new List<DiscordIntegration>(integrations_raw));
         }
 
         /// <summary>
         /// Gets the guild preview async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PREVIEW}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordGuildPreview>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Creates the guild integration async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="type">The type.</param>
         /// <param name="id">The id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordIntegration> CreateGuildIntegrationAsync(ulong guild_id, string type, ulong id)
         {
             var pld = new RestGuildIntegrationAttachPayload
             {
                 Type = type,
                 Id = id
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Modifies the guild integration async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="integration_id">The integration_id.</param>
         /// <param name="expire_behaviour">The expire_behaviour.</param>
         /// <param name="expire_grace_period">The expire_grace_period.</param>
         /// <param name="enable_emoticons">If true, enable_emoticons.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordIntegration> ModifyGuildIntegrationAsync(ulong guild_id, ulong integration_id, int expire_behaviour, int expire_grace_period, bool enable_emoticons)
         {
             var pld = new RestGuildIntegrationModifyPayload
             {
                 ExpireBehavior = expire_behaviour,
                 ExpireGracePeriod = expire_grace_period,
                 EnableEmoticons = enable_emoticons
             };
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, integration_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the guild integration async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="integration">The integration.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteGuildIntegrationAsync(ulong guild_id, DiscordIntegration integration)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, integration_id = integration.Id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, payload: DiscordJson.SerializeObject(integration));
         }
 
         /// <summary>
         /// Syncs the guild integration async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="integration_id">The integration_id.</param>
         /// <returns>A Task.</returns>
         internal Task SyncGuildIntegrationAsync(ulong guild_id, ulong integration_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id{Endpoints.SYNC}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id, integration_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
         }
 
         /// <summary>
         /// Gets the guild voice regions async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordVoiceRegion>> GetGuildVoiceRegionsAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.REGIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var regions_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
             return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regions_raw));
         }
 
         /// <summary>
         /// Gets the guild invites async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordInvite>> GetGuildInvitesAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INVITES}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var invites_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
             return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invites_raw));
         }
         #endregion
 
         #region Invite
         /// <summary>
         /// Gets the invite async.
         /// </summary>
         /// <param name="invite_code">The invite_code.</param>
         /// <param name="with_counts">If true, with_counts.</param>
         /// <param name="with_expiration">If true, with_expiration.</param>
         /// <param name="guild_scheduled_event_id">The scheduled event id to get.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordInvite> GetInviteAsync(string invite_code, bool? with_counts, bool? with_expiration, ulong? guild_scheduled_event_id)
         {
             var urlparams = new Dictionary<string, string>();
             if (with_counts.HasValue)
                 urlparams["with_counts"] = with_counts?.ToString();
             if (with_expiration.HasValue)
                 urlparams["with_expiration"] = with_expiration?.ToString();
             if (guild_scheduled_event_id.HasValue)
                 urlparams["guild_scheduled_event_id"] = guild_scheduled_event_id?.ToString();
 
             var route = $"{Endpoints.INVITES}/:invite_code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { invite_code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the invite async.
         /// </summary>
         /// <param name="invite_code">The invite_code.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordInvite> DeleteInviteAsync(string invite_code, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.INVITES}/:invite_code";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { invite_code }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /*
          * Disabled due to API restrictions
          *
          * internal async Task<DiscordInvite> InternalAcceptInvite(string invite_code)
          * {
          *     this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "REST API", "Invite accept endpoint was used; this account is now likely unverified", DateTime.Now);
          *
          *     var url = new Uri($"{Utils.GetApiBaseUri(this.Configuration), Endpoints.INVITES}/{invite_code));
          *     var bucket = this.Rest.GetBucket(0, MajorParameterType.Unbucketed, url, HttpRequestMethod.POST);
          *     var res = await this.DoRequestAsync(this.Discord, bucket, url, HttpRequestMethod.POST).ConfigureAwait(false);
          *
          *     var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
          *     ret.Discord = this.Discord;
          *
          *     return ret;
          * }
          */
         #endregion
 
         #region Connections
         /// <summary>
         /// Gets the users connections async.
         /// </summary>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordConnection>> GetUsersConnectionsAsync()
         {
             var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CONNECTIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var connections_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordConnection>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
             return new ReadOnlyCollection<DiscordConnection>(new List<DiscordConnection>(connections_raw));
         }
         #endregion
 
         #region Voice
         /// <summary>
         /// Lists the voice regions async.
         /// </summary>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
         {
             var route = $"{Endpoints.VOICE}{Endpoints.REGIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var regions = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
             return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regions));
         }
         #endregion
 
         #region Webhooks
         /// <summary>
         /// Creates the webhook async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="base64_avatar">The base64_avatar.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWebhook> CreateWebhookAsync(ulong channel_id, string name, Optional<string> base64_avatar, string reason)
         {
             var pld = new RestWebhookPayload
             {
                 Name = name,
                 AvatarBase64 = base64_avatar.HasValue ? base64_avatar.Value : null,
                 AvatarSet = base64_avatar.HasValue
             };
 
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
             ret.Discord = this.Discord;
             ret.ApiClient = this;
 
             return ret;
         }
 
         /// <summary>
         /// Gets the channel webhooks async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordWebhook>> GetChannelWebhooksAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var webhooks_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
             return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooks_raw));
         }
 
         /// <summary>
         /// Gets the guild webhooks async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordWebhook>> GetGuildWebhooksAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WEBHOOKS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var webhooks_raw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
             return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooks_raw));
         }
 
         /// <summary>
         /// Gets the webhook async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWebhook> GetWebhookAsync(ulong webhook_id)
         {
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { webhook_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
             ret.Discord = this.Discord;
             ret.ApiClient = this;
 
             return ret;
         }
 
         /// <summary>
         /// Gets the webhook with token async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong webhook_id, string webhook_token)
         {
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { webhook_id, webhook_token }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
             ret.Token = webhook_token;
             ret.Id = webhook_id;
             ret.Discord = this.Discord;
             ret.ApiClient = this;
 
             return ret;
         }
 
         /// <summary>
         /// Modifies the webhook async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="channelId">The channel id.</param>
         /// <param name="name">The name.</param>
         /// <param name="base64_avatar">The base64_avatar.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhook_id, ulong channelId, string name, Optional<string> base64_avatar, string reason)
         {
             var pld = new RestWebhookPayload
             {
                 Name = name,
                 AvatarBase64 = base64_avatar.HasValue ? base64_avatar.Value : null,
                 AvatarSet = base64_avatar.HasValue,
                 ChannelId = channelId
             };
 
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { webhook_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
             ret.Discord = this.Discord;
             ret.ApiClient = this;
 
             return ret;
         }
 
         /// <summary>
         /// Modifies the webhook async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="base64_avatar">The base64_avatar.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhook_id, string name, string base64_avatar, string webhook_token, string reason)
         {
             var pld = new RestWebhookPayload
             {
                 Name = name,
                 AvatarBase64 = base64_avatar
             };
 
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { webhook_id, webhook_token }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
             ret.Discord = this.Discord;
             ret.ApiClient = this;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the webhook async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteWebhookAsync(ulong webhook_id, string reason)
         {
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { webhook_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Deletes the webhook async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteWebhookAsync(ulong webhook_id, string webhook_token, string reason)
         {
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { webhook_id, webhook_token }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         /// <summary>
         /// Executes the webhook async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="builder">The builder.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> ExecuteWebhookAsync(ulong webhook_id, string webhook_token, DiscordWebhookBuilder builder, string thread_id)
         {
             builder.Validate();
 
             if (builder.Embeds != null)
                 foreach (var embed in builder.Embeds)
                     if (embed.Timestamp != null)
                         embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
             var values = new Dictionary<string, string>();
             var pld = new RestWebhookExecutePayload
             {
                 Content = builder.Content,
                 Username = builder.Username.HasValue ? builder.Username.Value : null,
                 AvatarUrl = builder.AvatarUrl.HasValue ? builder.AvatarUrl.Value : null,
                 IsTTS = builder.IsTTS,
                 Embeds = builder.Embeds,
                 Components = builder.Components
             };
 
             if (builder.Mentions != null)
                 pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
             if (builder.Files?.Count > 0)
             {
                 ulong file_id = 0;
                 List<DiscordAttachment> attachments = new();
                 foreach (var file in builder.Files)
                 {
                     DiscordAttachment att = new()
                     {
                         Id = file_id,
                         Discord = this.Discord,
                         Description = file.Description,
                         FileName = file.FileName,
                         FileSize = null
                     };
                     attachments.Add(att);
                     file_id++;
                 }
                 pld.Attachments = attachments;
             }
 
             if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.Files?.Count > 0 || builder.IsTTS == true || builder.Mentions != null)
                 values["payload_json"] = DiscordJson.SerializeObject(pld);
 
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { webhook_id, webhook_token }, out var path);
 
             var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
             if (thread_id != null)
                 qub.AddParameter("thread_id", thread_id);
 
             var url = qub.Build();
 
             var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
             var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
             foreach (var att in ret.Attachments)
                 att.Discord = this.Discord;
 
             foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
             {
                 file.Stream.Position = file.ResetPositionTo.Value;
             }
 
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Executes the webhook slack async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="json_payload">The json_payload.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> ExecuteWebhookSlackAsync(ulong webhook_id, string webhook_token, string json_payload, string thread_id)
         {
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.SLACK}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { webhook_id, webhook_token }, out var path);
 
             var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
             if (thread_id != null)
                 qub.AddParameter("thread_id", thread_id);
             var url = qub.Build();
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: json_payload).ConfigureAwait(false);
             var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Executes the webhook github async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="json_payload">The json_payload.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> ExecuteWebhookGithubAsync(ulong webhook_id, string webhook_token, string json_payload, string thread_id)
         {
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.GITHUB}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { webhook_id, webhook_token }, out var path);
 
             var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
             if (thread_id != null)
                 qub.AddParameter("thread_id", thread_id);
             var url = qub.Build();
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: json_payload).ConfigureAwait(false);
             var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Edits the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="builder">The builder.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> EditWebhookMessageAsync(ulong webhook_id, string webhook_token, string message_id, DiscordWebhookBuilder builder, string thread_id)
         {
             builder.Validate(true);
 
             var pld = new RestWebhookMessageEditPayload
             {
                 Content = builder.Content,
                 Embeds = builder.Embeds,
                 Mentions = builder.Mentions,
                 Components = builder.Components,
             };
 
             if (builder.Files?.Count > 0)
             {
                 ulong file_id = 0;
                 List<DiscordAttachment> attachments = new();
                 foreach (var file in builder.Files)
                 {
                     DiscordAttachment att = new()
                     {
                         Id = file_id,
                         Discord = this.Discord,
                         Description = file.Description,
                         FileName = file.FileName,
-                        FileSize = 0
+                        FileSize = null
                     };
                     attachments.Add(att);
                     file_id++;
                 }
                 if (builder.Attachments != null && builder.Attachments?.Count() > 0)
                     attachments.AddRange(builder.Attachments);
 
                 pld.Attachments = attachments;
+
+                var values = new Dictionary<string, string>
+                {
+                    ["payload_json"] = DiscordJson.SerializeObject(pld)
+                };
+                var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
+                var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { webhook_id, webhook_token, message_id }, out var path);
+
+                var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
+                if (thread_id != null)
+                    qub.AddParameter("thread_id", thread_id);
+
+                var url = qub.Build();
+                var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: builder.Files);
+
+                var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
+
+                ret.Discord = this.Discord;
+
+                foreach (var att in ret._attachments)
+                    att.Discord = this.Discord;
+
+                foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
+                {
+                    file.Stream.Position = file.ResetPositionTo.Value;
+                }
+
+                return ret;
             } else
             {
                 pld.Attachments = builder.Attachments;
-            }
 
-            var values = new Dictionary<string, string>
-            {
-                ["payload_json"] = DiscordJson.SerializeObject(pld)
-            };
-            var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
-            var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { webhook_id, webhook_token, message_id }, out var path);
+                var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
+                var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { webhook_id, webhook_token, message_id }, out var path);
 
-            var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
-            if (thread_id != null)
-                qub.AddParameter("thread_id", thread_id);
+                var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
+                if (thread_id != null)
+                    qub.AddParameter("thread_id", thread_id);
 
-            var url = qub.Build();
-            var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: builder.Files);
+                var url = qub.Build();
+                var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
-            var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
+                var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
-            ret.Discord = this.Discord;
+                ret.Discord = this.Discord;
 
-            foreach (var att in ret._attachments)
-                att.Discord = this.Discord;
+                foreach (var att in ret._attachments)
+                    att.Discord = this.Discord;
 
-            foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue)) {
-                file.Stream.Position = file.ResetPositionTo.Value;
+                return ret;
             }
-
-            return ret;
         }
 
         /// <summary>
         /// Edits the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="builder">The builder.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> EditWebhookMessageAsync(ulong webhook_id, string webhook_token, ulong message_id, DiscordWebhookBuilder builder, ulong thread_id) =>
             this.EditWebhookMessageAsync(webhook_id, webhook_token, message_id.ToString(), builder, thread_id.ToString());
 
         /// <summary>
         /// Gets the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> GetWebhookMessageAsync(ulong webhook_id, string webhook_token, string message_id, string thread_id)
         {
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { webhook_id, webhook_token, message_id }, out var path);
 
             var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
             if (thread_id != null)
                 qub.AddParameter("thread_id", thread_id);
             var url = qub.Build();
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Gets the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhook_id, string webhook_token, ulong message_id) =>
             this.GetWebhookMessageAsync(webhook_id, webhook_token, message_id.ToString(), null);
 
         /// <summary>
         /// Gets the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhook_id, string webhook_token, ulong message_id, ulong thread_id) =>
             this.GetWebhookMessageAsync(webhook_id, webhook_token, message_id.ToString(), thread_id.ToString());
 
         /// <summary>
         /// Deletes the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal async Task DeleteWebhookMessageAsync(ulong webhook_id, string webhook_token, string message_id, string thread_id)
         {
             var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { webhook_id, webhook_token, message_id }, out var path);
 
             var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
             if (thread_id != null)
                 qub.AddParameter("thread_id", thread_id);
             var url = qub.Build();
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Deletes the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteWebhookMessageAsync(ulong webhook_id, string webhook_token, ulong message_id) =>
             this.DeleteWebhookMessageAsync(webhook_id, webhook_token, message_id.ToString(), null);
 
         /// <summary>
         /// Deletes the webhook message async.
         /// </summary>
         /// <param name="webhook_id">The webhook_id.</param>
         /// <param name="webhook_token">The webhook_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="thread_id">The thread_id.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteWebhookMessageAsync(ulong webhook_id, string webhook_token, ulong message_id, ulong thread_id) =>
             this.DeleteWebhookMessageAsync(webhook_id, webhook_token, message_id.ToString(), thread_id.ToString());
         #endregion
 
         #region Reactions
         /// <summary>
         /// Creates the reaction async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="emoji">The emoji.</param>
         /// <returns>A Task.</returns>
         internal Task CreateReactionAsync(ulong channel_id, ulong message_id, string emoji)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id, message_id, emoji }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
         }
 
         /// <summary>
         /// Deletes the own reaction async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="emoji">The emoji.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteOwnReactionAsync(ulong channel_id, ulong message_id, string emoji)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, message_id, emoji }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
         }
 
         /// <summary>
         /// Deletes the user reaction async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="user_id">The user_id.</param>
         /// <param name="emoji">The emoji.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteUserReactionAsync(ulong channel_id, ulong message_id, ulong user_id, string emoji, string reason)
         {
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, message_id, emoji, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
         }
 
         /// <summary>
         /// Gets the reactions async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="emoji">The emoji.</param>
         /// <param name="after_id">The after_id.</param>
         /// <param name="limit">The limit.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(ulong channel_id, ulong message_id, string emoji, ulong? after_id = null, int limit = 25)
         {
             var urlparams = new Dictionary<string, string>();
             if (after_id.HasValue)
                 urlparams["after"] = after_id.Value.ToString(CultureInfo.InvariantCulture);
 
             urlparams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id, message_id, emoji }, out var path);
 
             var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var reacters_raw = JsonConvert.DeserializeObject<IEnumerable<TransportUser>>(res.Response);
             var reacters = new List<DiscordUser>();
             foreach (var xr in reacters_raw)
             {
                 var usr = new DiscordUser(xr) { Discord = this.Discord };
                 usr = this.Discord.UserCache.AddOrUpdate(xr.Id, usr, (id, old) =>
                 {
                     old.Username = usr.Username;
                     old.Discriminator = usr.Discriminator;
                     old.AvatarHash = usr.AvatarHash;
                     return old;
                 });
 
                 reacters.Add(usr);
             }
 
             return new ReadOnlyCollection<DiscordUser>(new List<DiscordUser>(reacters));
         }
 
         /// <summary>
         /// Deletes the all reactions async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteAllReactionsAsync(ulong channel_id, ulong message_id, string reason)
         {
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
         }
 
         /// <summary>
         /// Deletes the reactions emoji async.
         /// </summary>
         /// <param name="channel_id">The channel_id.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="emoji">The emoji.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteReactionsEmojiAsync(ulong channel_id, ulong message_id, string emoji)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, message_id, emoji }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
         }
         #endregion
 
         #region Threads
 
         /// <summary>
         /// Creates the thread with message.
         /// </summary>
         /// <param name="channel_id">The channel id to create the thread in.</param>
         /// <param name="message_id">The message id to create the thread from.</param>
         /// <param name="name">The name of the thread.</param>
         /// <param name="auto_archive_duration">The auto_archive_duration for the thread.</param>
         /// <param name="rate_limit_per_user">The rate limit per user.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordThreadChannel> CreateThreadWithMessageAsync(ulong channel_id, ulong message_id, string name, ThreadAutoArchiveDuration auto_archive_duration, int? rate_limit_per_user, string reason = null)
         {
             var pld = new RestThreadChannelCreatePayload
             {
                 Name = name,
                 AutoArchiveDuration = auto_archive_duration,
                 PerUserRateLimit = rate_limit_per_user
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.THREADS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
             var thread_channel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
             return thread_channel;
         }
 
         /// <summary>
         /// Creates the thread without a message.
         /// </summary>
         /// <param name="channel_id">The channel id to create the thread in.</param>
         /// <param name="name">The name of the thread.</param>
         /// <param name="auto_archive_duration">The auto_archive_duration for the thread.</param>
         /// <param name="type">Can be either <see cref="ChannelType.PublicThread"/> or <see cref="ChannelType.PrivateThread"/>.</param>
         /// <param name="rate_limit_per_user">The rate limit per user.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordThreadChannel> CreateThreadWithoutMessageAsync(ulong channel_id, string name, ThreadAutoArchiveDuration auto_archive_duration, ChannelType type = ChannelType.PublicThread, int? rate_limit_per_user = null, string reason = null)
         {
             var pld = new RestThreadChannelCreatePayload
             {
                 Name = name,
                 AutoArchiveDuration = auto_archive_duration,
                 PerUserRateLimit = rate_limit_per_user,
                 Type = type
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
             var thread_channel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
             return thread_channel;
         }
 
         /// <summary>
         /// Gets the thread.
         /// </summary>
         /// <param name="thread_id">The thread id.</param>
         internal async Task<DiscordThreadChannel> GetThreadAsync(ulong thread_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { thread_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var ret = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Joins the thread.
         /// </summary>
         /// <param name="channel_id">The channel id.</param>
         internal async Task JoinThreadAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
         }
 
         /// <summary>
         /// Leaves the thread.
         /// </summary>
         /// <param name="channel_id">The channel id.</param>
         internal async Task LeaveThreadAsync(ulong channel_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Adds a thread member.
         /// </summary>
         /// <param name="channel_id">The channel id to add the member to.</param>
         /// <param name="user_id">The user id to add.</param>
         internal async Task AddThreadMemberAsync(ulong channel_id, ulong user_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
         }
 
         /// <summary>
         /// Gets a thread member.
         /// </summary>
         /// <param name="channel_id">The channel id to get the member from.</param>
         /// <param name="user_id">The user id to get.</param>
         internal async Task<DiscordThreadChannelMember> GetThreadMemberAsync(ulong channel_id, ulong user_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var thread_member = JsonConvert.DeserializeObject<DiscordThreadChannelMember>(res.Response);
 
             return thread_member;
         }
 
         /// <summary>
         /// Removes a thread member.
         /// </summary>
         /// <param name="channel_id">The channel id to remove the member from.</param>
         /// <param name="user_id">The user id to remove.</param>
         internal async Task RemoveThreadMemberAsync(ulong channel_id, ulong user_id)
         {
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id, user_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Gets the thread members.
         /// </summary>
         /// <param name="thread_id">The thread id.</param>
         internal async Task<IReadOnlyList<DiscordThreadChannelMember>> GetThreadMembersAsync(ulong thread_id)
         {
             var route = $"{Endpoints.CHANNELS}/:thread_id{Endpoints.THREAD_MEMBERS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { thread_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var thread_members_raw = JsonConvert.DeserializeObject<List<DiscordThreadChannelMember>>(res.Response);
 
             return new ReadOnlyCollection<DiscordThreadChannelMember>(thread_members_raw);
         }
 
         /// <summary>
         /// Gets the active threads in a guild.
         /// </summary>
         /// <param name="guild_id">The guild id.</param>
         internal async Task<DiscordThreadResult> GetActiveThreadsAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.THREADS}{Endpoints.THREAD_ACTIVE}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var thread_return = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
             return thread_return;
         }
 
         /// <summary>
         /// Gets the joined private archived threads in a channel.
         /// </summary>
         /// <param name="channel_id">The channel id.</param>
         /// <param name="before">Get threads before snowflake.</param>
         /// <param name="limit">Limit the results.</param>
         internal async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong channel_id, ulong? before, int? limit)
         {
             var urlparams = new Dictionary<string, string>();
             if (before != null)
                 urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
             if (limit != null && limit > 0)
                 urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.USERS}{Endpoints.ME}{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var thread_return = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
             return thread_return;
         }
 
         /// <summary>
         /// Gets the public archived threads in a channel.
         /// </summary>
         /// <param name="channel_id">The channel id.</param>
         /// <param name="before">Get threads before snowflake.</param>
         /// <param name="limit">Limit the results.</param>
         internal async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong channel_id, ulong? before, int? limit)
         {
             var urlparams = new Dictionary<string, string>();
             if (before != null)
                 urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
             if (limit != null && limit > 0)
                 urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PUBLIC}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var thread_return = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
             return thread_return;
         }
 
         /// <summary>
         /// Gets the private archived threads in a channel.
         /// </summary>
         /// <param name="channel_id">The channel id.</param>
         /// <param name="before">Get threads before snowflake.</param>
         /// <param name="limit">Limit the results.</param>
         internal async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong channel_id, ulong? before, int? limit)
         {
             var urlparams = new Dictionary<string, string>();
             if (before != null)
                 urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
             if (limit != null && limit > 0)
                 urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { channel_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var thread_return = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
             return thread_return;
         }
 
         /// <summary>
         /// Modifies a thread.
         /// </summary>
         /// <param name="thread_id">The thread to modify.</param>
         /// <param name="name">The new name.</param>
         /// <param name="locked">The new locked state.</param>
         /// <param name="archived">The new archived state.</param>
         /// <param name="autoArchiveDuration">The new auto archive duration.</param>
         /// <param name="perUserRateLimit">The new per user rate limit.</param>
         /// <param name="invitable">The new user invitable state.</param>
         /// <param name="reason">The reason for the modification.</param>
         internal Task ModifyThreadAsync(ulong thread_id, string name, Optional<bool?> locked, Optional<bool?> archived, Optional<ThreadAutoArchiveDuration?> autoArchiveDuration, Optional<int?> perUserRateLimit, Optional<bool?> invitable, string reason)
         {
             var pld = new RestThreadChannelModifyPayload
             {
                 Name = name,
                 Archived = archived,
                 AutoArchiveDuration = autoArchiveDuration,
                 Locked = locked,
                 PerUserRateLimit = perUserRateLimit,
                 Invitable = invitable
             };
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:thread_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { thread_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Deletes a thread.
         /// </summary>
         /// <param name="thread_id">The thread to delete.</param>
         /// <param name="reason">The reason for deletion.</param>
         internal Task DeleteThreadAsync(ulong thread_id, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var route = $"{Endpoints.CHANNELS}/:thread_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { thread_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
 
         #endregion
 
         #region Emoji
         /// <summary>
         /// Gets the guild emojis async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordGuildEmoji>> GetGuildEmojisAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var emojisRaw = JsonConvert.DeserializeObject<IEnumerable<JObject>>(res.Response);
 
             this.Discord.Guilds.TryGetValue(guild_id, out var gld);
             var users = new Dictionary<ulong, DiscordUser>();
             var emojis = new List<DiscordGuildEmoji>();
             foreach (var rawEmoji in emojisRaw)
             {
                 var xge = rawEmoji.ToObject<DiscordGuildEmoji>();
                 xge.Guild = gld;
 
                 var xtu = rawEmoji["user"]?.ToObject<TransportUser>();
                 if (xtu != null)
                 {
                     if (!users.ContainsKey(xtu.Id))
                     {
                         var user = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
                         users[user.Id] = user;
                     }
 
                     xge.User = users[xtu.Id];
                 }
 
                 emojis.Add(xge);
             }
 
             return new ReadOnlyCollection<DiscordGuildEmoji>(emojis);
         }
 
         /// <summary>
         /// Gets the guild emoji async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="emoji_id">The emoji_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildEmoji> GetGuildEmojiAsync(ulong guild_id, ulong emoji_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id, emoji_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             this.Discord.Guilds.TryGetValue(guild_id, out var gld);
 
             var emoji_raw = JObject.Parse(res.Response);
             var emoji = emoji_raw.ToObject<DiscordGuildEmoji>();
             emoji.Guild = gld;
 
             var xtu = emoji_raw["user"]?.ToObject<TransportUser>();
             if (xtu != null)
                 emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
             return emoji;
         }
 
         /// <summary>
         /// Creates the guild emoji async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="imageb64">The imageb64.</param>
         /// <param name="roles">The roles.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildEmoji> CreateGuildEmojiAsync(ulong guild_id, string name, string imageb64, IEnumerable<ulong> roles, string reason)
         {
             var pld = new RestGuildEmojiCreatePayload
             {
                 Name = name,
                 ImageB64 = imageb64,
                 Roles = roles?.ToArray()
             };
 
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             this.Discord.Guilds.TryGetValue(guild_id, out var gld);
 
             var emoji_raw = JObject.Parse(res.Response);
             var emoji = emoji_raw.ToObject<DiscordGuildEmoji>();
             emoji.Guild = gld;
 
             var xtu = emoji_raw["user"]?.ToObject<TransportUser>();
             emoji.User = xtu != null
                 ? gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu)
                 : this.Discord.CurrentUser;
 
             return emoji;
         }
 
         /// <summary>
         /// Modifies the guild emoji async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="emoji_id">The emoji_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="roles">The roles.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordGuildEmoji> ModifyGuildEmojiAsync(ulong guild_id, ulong emoji_id, string name, IEnumerable<ulong> roles, string reason)
         {
             var pld = new RestGuildEmojiModifyPayload
             {
                 Name = name,
                 Roles = roles?.ToArray()
             };
 
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id, emoji_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
             this.Discord.Guilds.TryGetValue(guild_id, out var gld);
 
             var emoji_raw = JObject.Parse(res.Response);
             var emoji = emoji_raw.ToObject<DiscordGuildEmoji>();
             emoji.Guild = gld;
 
             var xtu = emoji_raw["user"]?.ToObject<TransportUser>();
             if (xtu != null)
                 emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
             return emoji;
         }
 
         /// <summary>
         /// Deletes the guild emoji async.
         /// </summary>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="emoji_id">The emoji_id.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteGuildEmojiAsync(ulong guild_id, ulong emoji_id, string reason)
         {
             var headers = new Dictionary<string, string>();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, emoji_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
         #endregion
 
         #region Stickers
 
         /// <summary>
         /// Gets a sticker.
         /// </summary>
         /// <param name="sticker_id">The sticker id.</param>
         internal async Task<DiscordSticker> GetStickerAsync(ulong sticker_id)
         {
             var route = $"{Endpoints.STICKERS}/:sticker_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {sticker_id}, out var path);
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
             var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Gets the sticker packs.
         /// </summary>
         internal async Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
         {
             var route = $"{Endpoints.STICKERPACKS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response)["sticker_packs"] as JArray;
             var ret = json.ToDiscordObject<DiscordStickerPack[]>();
 
             return ret.ToList();
         }
 
         /// <summary>
         /// Gets the guild stickers.
         /// </summary>
         /// <param name="guild_id">The guild id.</param>
         internal async Task<IReadOnlyList<DiscordSticker>> GetGuildStickersAsync(ulong guild_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id}, out var path);
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
             var json = JArray.Parse(res.Response);
             var ret = json.ToDiscordObject<DiscordSticker[]>();
 
             for (var i = 0; i < ret.Length; i++)
             {
                 var stkr = ret[i];
                 stkr.Discord = this.Discord;
 
                 if (json[i]["user"] is JObject obj) // Null = Missing stickers perm //
                 {
                     var tsr = obj.ToDiscordObject<TransportUser>();
                     var usr = new DiscordUser(tsr) {Discord = this.Discord};
                     usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
                     {
                         old.Username = usr.Username;
                         old.Discriminator = usr.Discriminator;
                         old.AvatarHash = usr.AvatarHash;
                         return old;
                     });
                     stkr.User = usr;
                 }
             }
 
             return ret.ToList();
         }
 
         /// <summary>
         /// Gets a guild sticker.
         /// </summary>
         /// <param name="guild_id">The guild id.</param>
         /// <param name="sticker_id">The sticker id.</param>
         internal async Task<DiscordSticker> GetGuildStickerAsync(ulong guild_id, ulong sticker_id)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id, sticker_id}, out var path);
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var json = JObject.Parse(res.Response);
             var ret = json.ToDiscordObject<DiscordSticker>();
             if (json["user"] is not null) // Null = Missing stickers perm //
             {
                 var tsr = json["user"].ToDiscordObject<TransportUser>();
                 var usr = new DiscordUser(tsr) {Discord = this.Discord};
                 usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
                 {
                     old.Username = usr.Username;
                     old.Discriminator = usr.Discriminator;
                     old.AvatarHash = usr.AvatarHash;
                     return old;
                 });
                 ret.User = usr;
             }
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Creates the guild sticker.
         /// </summary>
         /// <param name="guild_id">The guild id.</param>
         /// <param name="name">The name.</param>
         /// <param name="description">The description.</param>
         /// <param name="tags">The tags.</param>
         /// <param name="file">The file.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordSticker> CreateGuildStickerAsync(ulong guild_id, string name, string description, string tags, DiscordMessageFile file, string reason)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id}, out var path);
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var res = await this.DoStickerMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, file, name, tags, description);
 
             var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Modifies the guild sticker.
         /// </summary>
         /// <param name="guild_id">The guild id.</param>
         /// <param name="sticker_id">The sticker id.</param>
         /// <param name="name">The name.</param>
         /// <param name="description">The description.</param>
         /// <param name="tags">The tags.</param>
         /// <param name="reason">The reason.</param>
         internal async Task<DiscordSticker> ModifyGuildStickerAsync(ulong guild_id, ulong sticker_id, Optional<string> name, Optional<string> description, Optional<string> tags, string reason)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id, sticker_id}, out var path);
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             var pld = new RestStickerModifyPayload()
             {
                 Name = name,
                 Description = description,
                 Tags = tags
             };
 
             var values = new Dictionary<string, string>
             {
                 ["payload_json"] = DiscordJson.SerializeObject(pld)
             };
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route);
             var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
             ret.Discord = this.Discord;
 
             return null;
         }
 
         /// <summary>
         /// Deletes the guild sticker async.
         /// </summary>
         /// <param name="guild_id">The guild id.</param>
         /// <param name="sticker_id">The sticker id.</param>
         /// <param name="reason">The reason.</param>
         internal async Task DeleteGuildStickerAsync(ulong guild_id, ulong sticker_id, string reason)
         {
             var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { guild_id, sticker_id }, out var path);
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers.Add(REASON_HEADER_NAME, reason);
 
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
         }
         #endregion
 
         #region Application Commands
         /// <summary>
         /// Gets the global application commands async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(ulong application_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
             foreach (var app in ret)
                 app.Discord = this.Discord;
             return ret.ToList();
         }
 
         /// <summary>
         /// Bulks the overwrite global application commands async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="commands">The commands.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(ulong application_id, IEnumerable<DiscordApplicationCommand> commands)
         {
             var pld = new List<RestApplicationCommandCreatePayload>();
             foreach (var command in commands)
             {
                 pld.Add(new RestApplicationCommandCreatePayload
                 {
                     Type = command.Type,
                     Name = command.Name,
                     Description = command.Description,
                     Options = command.Options,
                     DefaultPermission = command.DefaultPermission
                 });
             }
 
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { application_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
             foreach (var app in ret)
                 app.Discord = this.Discord;
             return ret.ToList();
         }
 
         /// <summary>
         /// Creates the global application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="command">The command.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(ulong application_id, DiscordApplicationCommand command)
         {
             var pld = new RestApplicationCommandCreatePayload
             {
                 Type = command.Type,
                 Name = command.Name,
                 Description = command.Description,
                 Options = command.Options,
                 DefaultPermission = command.DefaultPermission
             };
 
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { application_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Gets the global application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="command_id">The command_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong application_id, ulong command_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Edits the global application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="command_id">The command_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="description">The description.</param>
         /// <param name="options">The options.</param>
         /// <param name="default_permission">The default_permission.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong application_id, ulong command_id, Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options, Optional<bool> default_permission)
         {
             var pld = new RestApplicationCommandEditPayload
             {
                 Name = name,
                 Description = description,
                 Options = options,
                 DefaultPermission = default_permission
             };
 
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { application_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the global application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="command_id">The command_id.</param>
         /// <returns>A Task.</returns>
         internal async Task DeleteGlobalApplicationCommandAsync(ulong application_id, ulong command_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { application_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Gets the guild application commands async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="guild_id">The guild_id.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong application_id, ulong guild_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id, guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
             foreach (var app in ret)
                 app.Discord = this.Discord;
             return ret.ToList();
         }
 
         /// <summary>
         /// Bulks the overwrite guild application commands async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="commands">The commands.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong application_id, ulong guild_id, IEnumerable<DiscordApplicationCommand> commands)
         {
             var pld = new List<RestApplicationCommandCreatePayload>();
             foreach (var command in commands)
             {
                 pld.Add(new RestApplicationCommandCreatePayload
                 {
                     Type = command.Type,
                     Name = command.Name,
                     Description = command.Description,
                     Options = command.Options,
                     DefaultPermission = command.DefaultPermission
                 });
             }
 
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { application_id, guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
             foreach (var app in ret)
                 app.Discord = this.Discord;
             return ret.ToList();
         }
 
         /// <summary>
         /// Creates the guild application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="command">The command.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong application_id, ulong guild_id, DiscordApplicationCommand command)
         {
             var pld = new RestApplicationCommandCreatePayload
             {
                 Type = command.Type,
                 Name = command.Name,
                 Description = command.Description,
                 Options = command.Options,
                 DefaultPermission = command.DefaultPermission
 
             };
 
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { application_id, guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Gets the guild application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="command_id">The command_id.</param>
         internal async Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong application_id, ulong guild_id, ulong command_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id, guild_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Edits the guild application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="command_id">The command_id.</param>
         /// <param name="name">The name.</param>
         /// <param name="description">The description.</param>
         /// <param name="options">The options.</param>
         /// <param name="default_permission">The default_permission.</param>
         internal async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong application_id, ulong guild_id, ulong command_id, Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options, Optional<bool> default_permission)
         {
             var pld = new RestApplicationCommandEditPayload
             {
                 Name = name,
                 Description = description,
                 Options = options,
                 DefaultPermission = default_permission
             };
 
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { application_id, guild_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Deletes the guild application command async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="guild_id">The guild_id.</param>
         /// <param name="command_id">The command_id.</param>
         internal async Task DeleteGuildApplicationCommandAsync(ulong application_id, ulong guild_id, ulong command_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { application_id, guild_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
         }
 
         /// <summary>
         /// Gets the guild application command permissions.
         /// </summary>
         /// <param name="application_id">The target application id.</param>
         /// <param name="guild_id">The target guild id.</param>
         internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong application_id, ulong guild_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id, guild_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
             foreach (var app in ret)
                 app.Discord = this.Discord;
 
             return ret.ToList();
         }
 
         /// <summary>
         /// Gets the application command permission.
         /// </summary>
         /// <param name="application_id">The target application id.</param>
         /// <param name="guild_id">The target guild id.</param>
         /// <param name="command_id">The target command id.</param>
         internal async Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong application_id, ulong guild_id, ulong command_id)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id, guild_id, command_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
             var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Overwrites the guild application command permissions.
         /// </summary>
         /// <param name="application_id">The target application id.</param>
         /// <param name="guild_id">The target guild id.</param>
         /// <param name="command_id">The target command id.</param>
         /// <param name="permissions">Array of permissions.</param>
         internal async Task<DiscordGuildApplicationCommandPermission> OverwriteGuildApplicationCommandPermissionsAsync(ulong application_id, ulong guild_id, ulong command_id, IEnumerable<DiscordApplicationCommandPermission> permissions)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { application_id, guild_id, command_id }, out var path);
 
             if (permissions.ToArray().Length > 10)
                 throw new NotSupportedException("You can add only up to 10 permission overwrites per command.");
 
             var pld = new RestApplicationCommandPermissionEditPayload
             {
                 Permissions = permissions
             };
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
             var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
             ret.Discord = this.Discord;
 
             return ret;
         }
 
         /// <summary>
         /// Bulks overwrite the application command permissions.
         /// </summary>
         /// <param name="application_id">The target application id.</param>
         /// <param name="guild_id">The target guild id.</param>
         /// <param name="permission_overwrites"></param>
         internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> BulkOverwriteApplicationCommandPermissionsAsync(ulong application_id, ulong guild_id, IEnumerable<DiscordGuildApplicationCommandPermission> permission_overwrites)
         {
             var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { application_id, guild_id }, out var path);
 
             var pld = new List<RestGuildApplicationCommandPermissionEditPayload>();
             foreach (var overwrite in permission_overwrites)
             {
                 if (overwrite.Permissions.Count > 10)
                     throw new NotSupportedException("You can add only up to 10 permission overwrites per command.");
 
                 pld.Add(new RestGuildApplicationCommandPermissionEditPayload
                 {
                     CommandId = overwrite.Id,
                     Permissions = overwrite.Permissions
                 });
             }
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld.ToArray()));
 
             var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
             foreach (var app in ret)
                 app.Discord = this.Discord;
 
             return ret.ToList();
         }
 
         /// <summary>
         /// Creates the interaction response async.
         /// </summary>
         /// <param name="interaction_id">The interaction_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="type">The type.</param>
         /// <param name="builder">The builder.</param>
         /// <returns>A Task.</returns>
         internal async Task CreateInteractionResponseAsync(ulong interaction_id, string interaction_token, InteractionResponseType type, DiscordInteractionResponseBuilder builder)
         {
             if (builder?.Embeds != null)
                 foreach (var embed in builder.Embeds)
                     if (embed.Timestamp != null)
                         embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
             RestInteractionResponsePayload pld;
 
             if (type != InteractionResponseType.AutoCompleteResult)
             {
                 var data = builder != null ? new DiscordInteractionApplicationCommandCallbackData
                 {
                     Content = builder.Content ?? null,
                     Embeds = builder.Embeds ?? null,
                     IsTTS = builder.IsTTS,
                     Mentions = builder.Mentions ?? null,
                     Flags = builder.IsEphemeral ? MessageFlags.Ephemeral : null,
                     Components = builder.Components ?? null,
                     Choices = null
                 } : null;
 
 
                 pld = new RestInteractionResponsePayload
                 {
                     Type = type,
                     Data = data 
                 };
 
 
                 if (builder != null && builder.Files != null && builder.Files.Count > 0)
                 {
                     ulong file_id = 0;
                     List<DiscordAttachment> attachments = new();
                     foreach (var file in builder.Files)
                     {
                         DiscordAttachment att = new()
                         {
                             Id = file_id,
                             Discord = this.Discord,
                             Description = file.Description,
                             FileName = file.FileName,
                             FileSize = null
                         };
                         attachments.Add(att);
                         file_id++;
                     }
                     pld.Attachments = attachments;
                     pld.Data.Attachments = attachments;
                 }
             }
             else
             {
                 pld = new RestInteractionResponsePayload
                 {
                     Type = type,
                     Data = new DiscordInteractionApplicationCommandCallbackData
                     {
                         Content = null,
                         Embeds = null,
                         IsTTS = null,
                         Mentions = null,
                         Flags = null,
                         Components = null,
                         Choices = builder.Choices,
                         Attachments = null
                     },
                     Attachments = null
                 };
             }
 
             var values = new Dictionary<string, string>();
 
             if (builder != null)
                 if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.IsTTS == true || builder.Mentions != null || builder.Files?.Count > 0)
                     values["payload_json"] = DiscordJson.SerializeObject(pld);
 
             var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { interaction_id, interaction_token }, out var path);
 
             var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "false").Build();
             if (builder != null)
             {
                 await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files);
 
                 foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
                 {
                     file.Stream.Position = file.ResetPositionTo.Value;
                 }
             }
             else
             {
                 await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
             }
         }
 
         /// <summary>
         /// Creates the interaction response async.
         /// </summary>
         /// <param name="interaction_id">The interaction_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="type">The type.</param>
         /// <param name="builder">The builder.</param>
         /// <returns>A Task.</returns>
         internal async Task CreateInteractionModalResponseAsync(ulong interaction_id, string interaction_token, InteractionResponseType type, DiscordInteractionModalBuilder builder)
         {
             var pld = new RestInteractionModalResponsePayload
             {
                 Type = type,
                 Data = new DiscordInteractionApplicationCommandModalCallbackData
                 {
                     Title = builder.Title,
                     CustomId = builder.CustomId,
                     ModalComponents = builder.ModalComponents
                 }
             };
 
             var values = new Dictionary<string, string>();
 
             if (type == InteractionResponseType.Modal)
                 this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
             var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { interaction_id, interaction_token }, out var path);
 
             var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
             await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
         }
 
         /// <summary>
         /// Gets the original interaction response async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> GetOriginalInteractionResponseAsync(ulong application_id, string interaction_token) =>
             this.GetWebhookMessageAsync(application_id, interaction_token, Endpoints.ORIGINAL, null);
 
         /// <summary>
         /// Edits the original interaction response async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="builder">The builder.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> EditOriginalInteractionResponseAsync(ulong application_id, string interaction_token, DiscordWebhookBuilder builder) =>
             this.EditWebhookMessageAsync(application_id, interaction_token, Endpoints.ORIGINAL, builder, null);
 
         /// <summary>
         /// Deletes the original interaction response async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteOriginalInteractionResponseAsync(ulong application_id, string interaction_token) =>
             this.DeleteWebhookMessageAsync(application_id, interaction_token, Endpoints.ORIGINAL, null);
 
         /// <summary>
         /// Creates the followup message async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="builder">The builder.</param>
         /// <returns>A Task.</returns>
         internal async Task<DiscordMessage> CreateFollowupMessageAsync(ulong application_id, string interaction_token, DiscordFollowupMessageBuilder builder)
         {
             builder.Validate();
 
             if (builder.Embeds != null)
                 foreach (var embed in builder.Embeds)
                     if (embed.Timestamp != null)
                         embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
             var values = new Dictionary<string, string>();
             var pld = new RestFollowupMessageCreatePayload
             {
                 Content = builder.Content,
                 IsTTS = builder.IsTTS,
                 Embeds = builder.Embeds,
                 Flags = builder.Flags,
                 Components = builder.Components
             };
 
 
             if (builder.Files != null && builder.Files.Count > 0)
             {
                 ulong file_id = 0;
                 List<DiscordAttachment> attachments = new();
                 foreach (var file in builder.Files)
                 {
                     DiscordAttachment att = new()
                     {
                         Id = file_id,
                         Discord = this.Discord,
                         Description = file.Description,
                         FileName = file.FileName,
                         FileSize = null
                     };
                     attachments.Add(att);
                     file_id++;
                 }
                 pld.Attachments = attachments;
             }
 
             if (builder.Mentions != null)
                 pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
             if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.IsTTS == true || builder.Mentions != null || builder.Files?.Count > 0)
                 values["payload_json"] = DiscordJson.SerializeObject(pld);
 
             var route = $"{Endpoints.WEBHOOKS}/:application_id/:interaction_token";
             var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { application_id, interaction_token }, out var path);
 
             var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
             var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
             var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
             foreach (var att in ret._attachments)
             {
                 att.Discord = this.Discord;
             }
 
             foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
             {
                 file.Stream.Position = file.ResetPositionTo.Value;
             }
 
             ret.Discord = this.Discord;
             return ret;
         }
 
         /// <summary>
         /// Gets the followup message async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> GetFollowupMessageAsync(ulong application_id, string interaction_token, ulong message_id) =>
             this.GetWebhookMessageAsync(application_id, interaction_token, message_id);
 
         /// <summary>
         /// Edits the followup message async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <param name="builder">The builder.</param>
         /// <returns>A Task.</returns>
         internal Task<DiscordMessage> EditFollowupMessageAsync(ulong application_id, string interaction_token, ulong message_id, DiscordWebhookBuilder builder) =>
             this.EditWebhookMessageAsync(application_id, interaction_token, message_id.ToString(), builder, null);
 
         /// <summary>
         /// Deletes the followup message async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <param name="interaction_token">The interaction_token.</param>
         /// <param name="message_id">The message_id.</param>
         /// <returns>A Task.</returns>
         internal Task DeleteFollowupMessageAsync(ulong application_id, string interaction_token, ulong message_id) =>
             this.DeleteWebhookMessageAsync(application_id, interaction_token, message_id);
         #endregion
 
         #region Misc
         /// <summary>
         /// Gets the current application info async.
         /// </summary>
         /// <returns>A Task.</returns>
         internal Task<TransportApplication> GetCurrentApplicationInfoAsync()
             => this.GetApplicationInfoAsync("@me");
 
         /// <summary>
         /// Gets the application info async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <returns>A Task.</returns>
         internal Task<TransportApplication> GetApplicationInfoAsync(ulong application_id)
             => this.GetApplicationInfoAsync(application_id.ToString(CultureInfo.InvariantCulture));
 
         /// <summary>
         /// Gets the application info async.
         /// </summary>
         /// <param name="application_id">The application_id.</param>
         /// <returns>A Task.</returns>
         private async Task<TransportApplication> GetApplicationInfoAsync(string application_id)
         {
             var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             return JsonConvert.DeserializeObject<TransportApplication>(res.Response);
         }
 
         /// <summary>
         /// Gets the application assets async.
         /// </summary>
         /// <param name="application">The application.</param>
         /// <returns>A Task.</returns>
         internal async Task<IReadOnlyList<DiscordApplicationAsset>> GetApplicationAssetsAsync(DiscordApplication application)
         {
             var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id{Endpoints.ASSETS}";
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id = application.Id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
             var assets = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationAsset>>(res.Response);
             foreach (var asset in assets)
             {
                 asset.Discord = application.Discord;
                 asset.Application = application;
             }
 
             return new ReadOnlyCollection<DiscordApplicationAsset>(new List<DiscordApplicationAsset>(assets));
         }
 
         /// <summary>
         /// Gets the gateway info async.
         /// </summary>
         /// <returns>A Task.</returns>
         internal async Task<GatewayInfo> GetGatewayInfoAsync()
         {
             var headers = Utilities.GetBaseHeaders();
             var route = Endpoints.GATEWAY;
             if (this.Discord.Configuration.TokenType == TokenType.Bot)
                 route += Endpoints.BOT;
             var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, headers).ConfigureAwait(false);
 
             var info = JObject.Parse(res.Response).ToObject<GatewayInfo>();
             info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.resetAfter);
             return info;
         }
         #endregion
 
         #region DCS Internals
         /// <summary>
         /// Gets the DisCatSharp team.
         /// </summary>>
         internal async Task<DisCatSharpTeam> GetDisCatSharpTeamAsync()
         {
             try
             {
                 var wc = new WebClient();
                 var dcs = await wc.DownloadStringTaskAsync(new Uri("https://dcs.aitsys.dev/api/devs/"));
                 var dcs_guild = await wc.DownloadStringTaskAsync(new Uri("https://dcs.aitsys.dev/api/guild/"));
 
                 var app = JsonConvert.DeserializeObject<TransportApplication>(dcs);
                 var guild = JsonConvert.DeserializeObject<DiscordGuild>(dcs_guild);
 
                 var dcst = new DisCatSharpTeam
                 {
                     IconHash = app.Team.IconHash,
                     TeamName = app.Team.Name,
                     PrivacyPolicyUrl = app.PrivacyPolicyUrl,
                     TermsOfServiceUrl = app.TermsOfServiceUrl,
                     RepoUrl = "https://github.com/Aiko-IT-Systems/DisCatSharp",
                     DocsUrl = "https://docs.dcs.aitsys.dev",
                     Id = app.Team.Id,
                     BannerHash = guild.BannerHash,
                     LogoHash = guild.IconHash,
                     GuildId = guild.Id,
                     Guild = guild,
                     SupportInvite = await this.GetInviteAsync("discatsharp", true, true, null)
                 };
                 List<DisCatSharpTeamMember> team = new();
                 DisCatSharpTeamMember owner = new();
                 foreach (var mb in app.Team.Members.OrderBy(m => m.User.Username))
                 {
                     var tuser = await this.GetUserAsync(mb.User.Id);
                     var user = mb.User;
                     if (mb.User.Id == 856780995629154305)
                     {
                         owner.Id = user.Id;
                         owner.Username = user.Username;
                         owner.Discriminator = user.Discriminator;
                         owner.AvatarHash = user.AvatarHash;
                         owner.BannerHash = tuser.BannerHash;
                         owner._bannerColor = tuser._bannerColor;
                         team.Add(owner);
                     }
                     else
                     {
                         team.Add(new()
                         {
                             Id = user.Id,
                             Username = user.Username,
                             Discriminator = user.Discriminator,
                             AvatarHash = user.AvatarHash,
                             BannerHash = tuser.BannerHash,
                             _bannerColor = tuser._bannerColor
                         });
                     }
                 }
                 dcst.Owner = owner;
                 dcst.Developers = team;
 
                 return dcst;
             } catch(Exception ex)
             {
                 this.Discord.Logger.LogDebug(ex.Message);
                 this.Discord.Logger.LogDebug(ex.StackTrace);
                 return null;
             }
         }
         #endregion
     }
 }