diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.cs b/DisCatSharp/Entities/Guild/DiscordGuild.cs
index 3dfe52ea9..4aad6f5ef 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,3476 +1,3479 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a Discord guild.
     /// </summary>
     public class DiscordGuild : SnowflakeObject, IEquatable<DiscordGuild>
     {
         /// <summary>
         /// Gets the guild's name.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; internal set; }
 
         /// <summary>
         /// Gets the guild icon's hash.
         /// </summary>
         [JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
         public string IconHash { get; internal set; }
 
         /// <summary>
         /// Gets the guild icon's url.
         /// </summary>
         [JsonIgnore]
         public string IconUrl
             => !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.{(this.IconHash.StartsWith("a_") ? "gif" : "png")}?size=1024" : null;
 
         /// <summary>
         /// Gets the guild splash's hash.
         /// </summary>
         [JsonProperty("splash", NullValueHandling = NullValueHandling.Ignore)]
         public string SplashHash { get; internal set; }
 
         /// <summary>
         /// Gets the guild splash's url.
         /// </summary>
         [JsonIgnore]
         public string SplashUrl
          => !string.IsNullOrWhiteSpace(this.SplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.SplashHash}.png?size=1024" : null;
 
         /// <summary>
         /// Gets the guild discovery splash's hash.
         /// </summary>
         [JsonProperty("discovery_splash", NullValueHandling = NullValueHandling.Ignore)]
         public string DiscoverySplashHash { get; internal set; }
 
         /// <summary>
         /// Gets the guild discovery splash's url.
         /// </summary>
         [JsonIgnore]
         public string DiscoverySplashUrl
             => !string.IsNullOrWhiteSpace(this.DiscoverySplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILD_DISCOVERY_SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.DiscoverySplashHash}.png?size=1024" : null;
 
         /// <summary>
         /// Gets the preferred locale of this guild.
         /// <para>This is used for server discovery and notices from Discord. Defaults to en-US.</para>
         /// </summary>
         [JsonProperty("preferred_locale", NullValueHandling = NullValueHandling.Ignore)]
         public string PreferredLocale { get; internal set; }
 
         /// <summary>
         /// Gets the ID of the guild's owner.
         /// </summary>
         [JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong OwnerId { get; internal set; }
 
         /// <summary>
         /// Gets the guild's owner.
         /// </summary>
         [JsonIgnore]
         public DiscordMember Owner
             => this.Members.TryGetValue(this.OwnerId, out var owner)
                 ? owner
                 : this.Discord.ApiClient.GetGuildMemberAsync(this.Id, this.OwnerId).ConfigureAwait(false).GetAwaiter().GetResult();
 
         /// <summary>
         /// Gets permissions for the user in the guild (does not include channel overrides)
         /// </summary>
         [JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
         public Permissions? Permissions { get; set; }
 
         /// <summary>
         /// Gets the guild's voice region ID.
         /// </summary>
         [JsonProperty("region", NullValueHandling = NullValueHandling.Ignore)]
         internal string VoiceRegionId { get; set; }
 
         /// <summary>
         /// Gets the guild's voice region.
         /// </summary>
         [JsonIgnore]
         public DiscordVoiceRegion VoiceRegion
             => this.Discord.VoiceRegions[this.VoiceRegionId];
 
         /// <summary>
         /// Gets the guild's AFK voice channel ID.
         /// </summary>
         [JsonProperty("afk_channel_id", NullValueHandling = NullValueHandling.Ignore)]
         internal ulong AfkChannelId { get; set; } = 0;
 
         /// <summary>
         /// Gets the guild's AFK voice channel.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel AfkChannel
             => this.GetChannel(this.AfkChannelId);
 
         /// <summary>
         /// Gets the guild's AFK timeout.
         /// </summary>
         [JsonProperty("afk_timeout", NullValueHandling = NullValueHandling.Ignore)]
         public int AfkTimeout { get; internal set; }
 
         /// <summary>
         /// Gets the guild's verification level.
         /// </summary>
         [JsonProperty("verification_level", NullValueHandling = NullValueHandling.Ignore)]
         public VerificationLevel VerificationLevel { get; internal set; }
 
         /// <summary>
         /// Gets the guild's default notification settings.
         /// </summary>
         [JsonProperty("default_message_notifications", NullValueHandling = NullValueHandling.Ignore)]
         public DefaultMessageNotifications DefaultMessageNotifications { get; internal set; }
 
         /// <summary>
         /// Gets the guild's explicit content filter settings.
         /// </summary>
         [JsonProperty("explicit_content_filter")]
         public ExplicitContentFilter ExplicitContentFilter { get; internal set; }
 
         /// <summary>
         /// Gets the guild's nsfw level.
         /// </summary>
         [JsonProperty("nsfw_level")]
         public NsfwLevel NsfwLevel { get; internal set; }
 
         /// <summary>
         /// Gets the system channel id.
         /// </summary>
         [JsonProperty("system_channel_id", NullValueHandling = NullValueHandling.Include)]
         internal ulong? SystemChannelId { get; set; }
 
         /// <summary>
         /// Gets the channel where system messages (such as boost and welcome messages) are sent.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel SystemChannel => this.SystemChannelId.HasValue
             ? this.GetChannel(this.SystemChannelId.Value)
             : null;
 
         /// <summary>
         /// Gets the settings for this guild's system channel.
         /// </summary>
         [JsonProperty("system_channel_flags")]
         public SystemChannelFlags SystemChannelFlags { get; internal set; }
 
         /// <summary>
         /// Gets whether this guild's widget is enabled.
         /// </summary>
         [JsonProperty("widget_enabled", NullValueHandling = NullValueHandling.Ignore)]
         public bool? WidgetEnabled { get; internal set; }
 
         /// <summary>
         /// Gets the widget channel id.
         /// </summary>
         [JsonProperty("widget_channel_id", NullValueHandling = NullValueHandling.Ignore)]
         internal ulong? WidgetChannelId { get; set; }
 
         /// <summary>
         /// Gets the widget channel for this guild.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel WidgetChannel => this.WidgetChannelId.HasValue
             ? this.GetChannel(this.WidgetChannelId.Value)
             : null;
 
         /// <summary>
         /// Gets the rules channel id.
         /// </summary>
         [JsonProperty("rules_channel_id")]
         internal ulong? RulesChannelId { get; set; }
 
         /// <summary>
         /// Gets the rules channel for this guild.
         /// <para>This is only available if the guild is considered "discoverable".</para>
         /// </summary>
         [JsonIgnore]
         public DiscordChannel RulesChannel => this.RulesChannelId.HasValue
             ? this.GetChannel(this.RulesChannelId.Value)
             : null;
 
         /// <summary>
         /// Gets the public updates channel id.
         /// </summary>
         [JsonProperty("public_updates_channel_id")]
         internal ulong? PublicUpdatesChannelId { get; set; }
 
         /// <summary>
         /// Gets the public updates channel (where admins and moderators receive messages from Discord) for this guild.
         /// <para>This is only available if the guild is considered "discoverable".</para>
         /// </summary>
         [JsonIgnore]
         public DiscordChannel PublicUpdatesChannel => this.PublicUpdatesChannelId.HasValue
             ? this.GetChannel(this.PublicUpdatesChannelId.Value)
             : null;
 
         /// <summary>
         /// Gets the application id of this guild if it is bot created.
         /// </summary>
         [JsonProperty("application_id")]
         public ulong? ApplicationId { get; internal set; }
 
         /// <summary>
         /// Gets a collection of this guild's roles.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordRole> Roles => new ReadOnlyConcurrentDictionary<ulong, DiscordRole>(this._roles);
 
         [JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordRole> _roles;
 
         /// <summary>
         /// Gets a collection of this guild's stickers.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordSticker> Stickers => new ReadOnlyConcurrentDictionary<ulong, DiscordSticker>(this._stickers);
 
         [JsonProperty("stickers", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordSticker> _stickers;
 
         /// <summary>
         /// Gets a collection of this guild's emojis.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordEmoji> Emojis => new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(this._emojis);
 
         [JsonProperty("emojis", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordEmoji> _emojis;
 
         /// <summary>
         /// Gets a collection of this guild's features.
         /// </summary>
         [JsonProperty("features", NullValueHandling = NullValueHandling.Ignore)]
         public IReadOnlyList<string> RawFeatures { get; internal set; }
 
         /// <summary>
         /// Gets the guild's features.
         /// </summary>
         [JsonIgnore]
         public GuildFeatures Features => new(this);
 
         /// <summary>
         /// Gets the required multi-factor authentication level for this guild.
         /// </summary>
         [JsonProperty("mfa_level", NullValueHandling = NullValueHandling.Ignore)]
         public MfaLevel MfaLevel { get; internal set; }
 
         /// <summary>
         /// Gets this guild's join date.
         /// </summary>
         [JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
         public DateTimeOffset JoinedAt { get; internal set; }
 
         /// <summary>
         /// Gets whether this guild is considered to be a large guild.
         /// </summary>
         [JsonProperty("large", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsLarge { get; internal set; }
 
         /// <summary>
         /// Gets whether this guild is unavailable.
         /// </summary>
         [JsonProperty("unavailable", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsUnavailable { get; internal set; }
 
         /// <summary>
         /// Gets the total number of members in this guild.
         /// </summary>
         [JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
         public int MemberCount { get; internal set; }
 
         /// <summary>
         /// Gets the maximum amount of members allowed for this guild.
         /// </summary>
         [JsonProperty("max_members")]
         public int? MaxMembers { get; internal set; }
 
         /// <summary>
         /// Gets the maximum amount of presences allowed for this guild.
         /// </summary>
         [JsonProperty("max_presences")]
         public int? MaxPresences { get; internal set; }
 
 #pragma warning disable CS1734
         /// <summary>
         /// Gets the approximate number of members in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having <paramref name = "withCounts"></paramref> set to true.
         /// </summary>
         [JsonProperty("approximate_member_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? ApproximateMemberCount { get; internal set; }
 
         /// <summary>
         /// Gets the approximate number of presences in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having <paramref name = "withCounts"></paramref> set to true.
         /// </summary>
         [JsonProperty("approximate_presence_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? ApproximatePresenceCount { get; internal set; }
 
 #pragma warning restore CS1734
         /// <summary>
         /// Gets the maximum amount of users allowed per video channel.
         /// </summary>
         [JsonProperty("max_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
         public int? MaxVideoChannelUsers { get; internal set; }
 
         /// <summary>
         /// Gets a dictionary of all the voice states for this guilds. The key for this dictionary is the ID of the user
         /// the voice state corresponds to.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordVoiceState> VoiceStates => new ReadOnlyConcurrentDictionary<ulong, DiscordVoiceState>(this._voiceStates);
 
         [JsonProperty("voice_states", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordVoiceState> _voiceStates;
 
         /// <summary>
         /// Gets a dictionary of all the members that belong to this guild. The dictionary's key is the member ID.
         /// </summary>
         [JsonIgnore] // TODO overhead of => vs Lazy? it's a struct
         public IReadOnlyDictionary<ulong, DiscordMember> Members => new ReadOnlyConcurrentDictionary<ulong, DiscordMember>(this._members);
 
         [JsonProperty("members", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordMember> _members;
 
         /// <summary>
         /// Gets a dictionary of all the channels associated with this guild. The dictionary's key is the channel ID.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordChannel> Channels => new ReadOnlyConcurrentDictionary<ulong, DiscordChannel>(this._channels);
 
         [JsonProperty("channels", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordChannel> _channels;
 
         internal ConcurrentDictionary<string, DiscordInvite> _invites;
 
         /// <summary>
         /// Gets a dictionary of all the active threads associated with this guild the user has permission to view. The dictionary's key is the channel ID.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordThreadChannel> Threads { get; internal set; }
 
         [JsonProperty("threads", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordThreadChannel> _threads = new();
 
         /// <summary>
         /// Gets a dictionary of all active stage instances. The dictionary's key is the stage ID.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordStageInstance> StageInstances { get; internal set; }
 
         [JsonProperty("stage_instances", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordStageInstance> _stageInstances = new();
 
         /// <summary>
         /// Gets a dictionary of all scheduled events.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordScheduledEvent> ScheduledEvents { get; internal set; }
 
         [JsonProperty("guild_scheduled_events", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordScheduledEvent> _scheduledEvents = new();
 
         /// <summary>
         /// Gets the guild member for current user.
         /// </summary>
         [JsonIgnore]
         public DiscordMember CurrentMember
             => this._current_member_lazy.Value;
 
         [JsonIgnore]
         private readonly Lazy<DiscordMember> _current_member_lazy;
 
         /// <summary>
         /// Gets the @everyone role for this guild.
         /// </summary>
         [JsonIgnore]
         public DiscordRole EveryoneRole
             => this.GetRole(this.Id);
 
         [JsonIgnore]
         internal bool _isOwner;
 
         /// <summary>
         /// Gets whether the current user is the guild's owner.
         /// </summary>
         [JsonProperty("owner", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsOwner
         {
             get => this._isOwner || this.OwnerId == this.Discord.CurrentUser.Id;
             internal set => this._isOwner = value;
         }
 
         /// <summary>
         /// Gets the vanity URL code for this guild, when applicable.
         /// </summary>
         [JsonProperty("vanity_url_code")]
         public string VanityUrlCode { get; internal set; }
 
         /// <summary>
         /// Gets the guild description, when applicable.
         /// </summary>
         [JsonProperty("description")]
         public string Description { get; internal set; }
 
         /// <summary>
         /// Gets this guild's banner hash, when applicable.
         /// </summary>
         [JsonProperty("banner")]
         public string BannerHash { get; internal set; }
 
         /// <summary>
         /// Gets this guild's banner in url form.
         /// </summary>
         [JsonIgnore]
         public string BannerUrl
             => !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
         /// <summary>
         /// Whether this guild has the community feature enabled.
         /// </summary>
         [JsonIgnore]
         public bool IsCommunity => this.Features.HasCommunityEnabled;
 
         /// <summary>
         /// Whether this guild has enabled the welcome screen.
         /// </summary>
         [JsonIgnore]
         public bool HasWelcomeScreen => this.Features.HasWelcomeScreenEnabled;
 
         /// <summary>
         /// Whether this guild has enabled membership screening.
         /// </summary>
         [JsonIgnore]
         public bool HasMemberVerificationGate => this.Features.HasMembershipScreeningEnabled;
 
         /// <summary>
         /// Gets this guild's premium tier (Nitro boosting).
         /// </summary>
         [JsonProperty("premium_tier")]
         public PremiumTier PremiumTier { get; internal set; }
 
         /// <summary>
         /// Gets the amount of members that boosted this guild.
         /// </summary>
         [JsonProperty("premium_subscription_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? PremiumSubscriptionCount { get; internal set; }
 
         /// <summary>
         /// Whether the premium progress bar is enabled.
         /// </summary>
         [JsonProperty("premium_progress_bar_enabled", NullValueHandling = NullValueHandling.Ignore)]
         public bool PremiumProgressBarEnabled { get; internal set; }
 
         /// <summary>
         /// Gets whether this guild is designated as NSFW.
         /// </summary>
         [JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsNSFW { get; internal set; }
 
         /// <summary>
         /// Gets a dictionary of all by position ordered channels associated with this guild. The dictionary's key is the channel ID.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordChannel> OrderedChannels => new ReadOnlyDictionary<ulong, DiscordChannel>(this.InternalSortChannels());
 
         /// <summary>
         /// Sorts the channels.
         /// </summary>
         private Dictionary<ulong, DiscordChannel> InternalSortChannels()
         {
             Dictionary<ulong, DiscordChannel> keyValuePairs = new();
             var ochannels = this.GetOrderedChannels();
             foreach (var ochan in ochannels)
             {
                 if (ochan.Key != 0)
                     keyValuePairs.Add(ochan.Key, this.GetChannel(ochan.Key));
                 foreach (var chan in ochan.Value)
                     keyValuePairs.Add(chan.Id, chan);
             }
             return keyValuePairs;
         }
 
         /// <summary>
         /// Gets an ordered <see cref="DiscordChannel"/> list out of the channel cache.
         /// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
         /// Ignore the 0 key here, because that indicates that this is the "has no category" list.
         /// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
         /// </summary>
         /// <returns>A ordered list of categories with its channels</returns>
         public Dictionary<ulong, List<DiscordChannel>> GetOrderedChannels()
         {
             IReadOnlyList<DiscordChannel> raw_channels = this._channels.Values.ToList();
 
             Dictionary<ulong, List<DiscordChannel>> ordered_channels = new();
 
             ordered_channels.Add(0, new List<DiscordChannel>());
 
             foreach (var channel in raw_channels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
             {
                 ordered_channels.Add(channel.Id, new List<DiscordChannel>());
             }
 
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
 
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
 
             return ordered_channels;
         }
 
         /// <summary>
         /// Gets an ordered <see cref="DiscordChannel"/> list.
         /// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
         /// Ignore the 0 key here, because that indicates that this is the "has no category" list.
         /// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
         /// </summary>
         /// <returns>A ordered list of categories with its channels</returns>
         public async Task<Dictionary<ulong, List<DiscordChannel>>> GetOrderedChannelsAsync()
         {
             var raw_channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
             Dictionary<ulong, List<DiscordChannel>> ordered_channels = new();
 
             ordered_channels.Add(0, new List<DiscordChannel>());
 
             foreach (var channel in raw_channels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
             {
                 ordered_channels.Add(channel.Id, new List<DiscordChannel>());
             }
 
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[channel.ParentId.Value].Add(channel);
             }
 
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
             foreach (var channel in raw_channels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
             {
                 ordered_channels[0].Add(channel);
             }
 
             return ordered_channels;
         }
 
         /// <summary>
         /// Whether it is synced.
         /// </summary>
         [JsonIgnore]
         internal bool IsSynced { get; set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordGuild"/> class.
         /// </summary>
         internal DiscordGuild()
         {
             this._current_member_lazy = new Lazy<DiscordMember>(() => (this._members != null && this._members.TryGetValue(this.Discord.CurrentUser.Id, out var member)) ? member : null);
             this._invites = new ConcurrentDictionary<string, DiscordInvite>();
             this.Threads = new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannel>(this._threads);
             this.StageInstances = new ReadOnlyConcurrentDictionary<ulong, DiscordStageInstance>(this._stageInstances);
             this.ScheduledEvents = new ReadOnlyConcurrentDictionary<ulong, DiscordScheduledEvent>(this._scheduledEvents);
         }
 
         #region Guild Methods
 
         /// <summary>
         /// Searches the current guild for members who's display name start with the specified name.
         /// </summary>
         /// <param name="name">The name to search for.</param>
         /// <param name="limit">The maximum amount of members to return. Max 1000. Defaults to 1.</param>
         /// <returns>The members found, if any.</returns>
         public Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(string name, int? limit = 1)
             => this.Discord.ApiClient.SearchMembersAsync(this.Id, name, limit);
 
         /// <summary>
         /// Adds a new member to this guild
         /// </summary>
         /// <param name="user">User to add</param>
         /// <param name="access_token">User's access token (OAuth2)</param>
         /// <param name="nickname">new nickname</param>
         /// <param name="roles">new roles</param>
         /// <param name="muted">whether this user has to be muted</param>
         /// <param name="deaf">whether this user has to be deafened</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite" /> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="access_token"/> is not found.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddMemberAsync(DiscordUser user, string access_token, string nickname = null, IEnumerable<DiscordRole> roles = null,
             bool muted = false, bool deaf = false)
             => this.Discord.ApiClient.AddGuildMemberAsync(this.Id, user.Id, access_token, nickname, roles, muted, deaf);
 
         /// <summary>
         /// Deletes this guild. Requires the caller to be the owner of the guild.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client is not the owner of the guild.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteAsync()
             => this.Discord.ApiClient.DeleteGuildAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild.
         /// </summary>
         /// <param name="action">Action to perform on this guild..</param>
         /// <returns>The modified guild object.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> ModifyAsync(Action<GuildEditModel> action)
         {
             var mdl = new GuildEditModel();
             action(mdl);
 
             var afkChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.AfkChannel.HasValue && mdl.AfkChannel.Value.Type != ChannelType.Voice && mdl.AfkChannel.Value != null)
                 throw new ArgumentException("AFK channel needs to be a voice channel.");
             else if (mdl.AfkChannel.HasValue && mdl.AfkChannel.Value != null)
                 afkChannelId = mdl.AfkChannel.Value.Id;
             else if (mdl.AfkChannel.HasValue)
                 afkChannelId = null;
 
             var rulesChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.RulesChannel.HasValue && mdl.RulesChannel.Value != null && mdl.RulesChannel.Value.Type != ChannelType.Text && mdl.RulesChannel.Value.Type != ChannelType.News )
                 throw new ArgumentException("Rules channel needs to be a text channel.");
             else if (mdl.RulesChannel.HasValue && mdl.RulesChannel.Value != null)
                 rulesChannelId = mdl.RulesChannel.Value.Id;
             else if (mdl.RulesChannel.HasValue)
                 rulesChannelId = null;
 
             var publicUpdatesChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.PublicUpdatesChannel.HasValue && mdl.PublicUpdatesChannel.Value != null && mdl.PublicUpdatesChannel.Value.Type != ChannelType.Text && mdl.PublicUpdatesChannel.Value.Type != ChannelType.News)
                 throw new ArgumentException("Public updates channel needs to be a text channel.");
             else if (mdl.PublicUpdatesChannel.HasValue && mdl.PublicUpdatesChannel.Value != null)
                 publicUpdatesChannelId = mdl.PublicUpdatesChannel.Value.Id;
             else if (mdl.PublicUpdatesChannel.HasValue)
                 publicUpdatesChannelId = null;
 
             var systemChannelId = Optional.FromNoValue<ulong?>();
             if (mdl.SystemChannel.HasValue && mdl.SystemChannel.Value != null && mdl.SystemChannel.Value.Type != ChannelType.Text && mdl.SystemChannel.Value.Type != ChannelType.News)
                 throw new ArgumentException("Public updates channel needs to be a text channel.");
             else if (mdl.SystemChannel.HasValue && mdl.SystemChannel.Value != null)
                 systemChannelId = mdl.SystemChannel.Value.Id;
             else if (mdl.SystemChannel.HasValue)
                 systemChannelId = null;
 
             var iconb64 = Optional.FromNoValue<string>();
             if (mdl.Icon.HasValue && mdl.Icon.Value != null)
                 using (var imgtool = new ImageTool(mdl.Icon.Value))
                     iconb64 = imgtool.GetBase64();
             else if (mdl.Icon.HasValue)
                 iconb64 = null;
 
             var splashb64 = Optional.FromNoValue<string>();
             if (mdl.Splash.HasValue && mdl.Splash.Value != null)
                 using (var imgtool = new ImageTool(mdl.Splash.Value))
                     splashb64 = imgtool.GetBase64();
             else if (mdl.Splash.HasValue)
                 splashb64 = null;
 
             var bannerb64 = Optional.FromNoValue<string>();
             if (mdl.Banner.HasValue && mdl.Banner.Value != null)
                 using (var imgtool = new ImageTool(mdl.Banner.Value))
                     bannerb64 = imgtool.GetBase64();
             else if (mdl.Banner.HasValue)
                 bannerb64 = null;
 
             var discoverySplash64 = Optional.FromNoValue<string>();
             if (mdl.DiscoverySplash.HasValue && mdl.DiscoverySplash.Value != null)
                 using (var imgtool = new ImageTool(mdl.DiscoverySplash.Value))
                     discoverySplash64 = imgtool.GetBase64();
             else if (mdl.DiscoverySplash.HasValue)
                 discoverySplash64 = null;
 
             var description = Optional.FromNoValue<string>();
             if (mdl.Description.HasValue && mdl.Description.Value != null)
                 description = mdl.Description;
             else if (mdl.Description.HasValue)
                 description = null;
 
             return await this.Discord.ApiClient.ModifyGuildAsync(this.Id, mdl.Name,
                 mdl.VerificationLevel, mdl.DefaultMessageNotifications, mdl.MfaLevel, mdl.ExplicitContentFilter,
                 afkChannelId, mdl.AfkTimeout, iconb64, mdl.Owner.IfPresent(e => e.Id), splashb64,
                 systemChannelId, mdl.SystemChannelFlags, publicUpdatesChannelId, rulesChannelId,
                 description, bannerb64, discoverySplash64, mdl.PreferredLocale, mdl.PremiumProgressBarEnabled, mdl.AuditLogReason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Modifies the community settings async.
         /// This sets <see cref="VerificationLevel.High"/> if not highest and <see cref="ExplicitContentFilter.AllMembers"/>.
         /// </summary>
         /// <param name="enabled">If true, enable <see cref="GuildFeatures.HasCommunityEnabled"/>.</param>
         /// <param name="rulesChannel">The rules channel.</param>
         /// <param name="publicUpdatesChannel">The public updates channel.</param>
         /// <param name="preferredLocale">The preferred locale. Defaults to en-US.</param>
         /// <param name="description">The description.</param>
         /// <param name="defaultMessageNotifications">The default message notifications. Defaults to <see cref="DefaultMessageNotifications.MentionsOnly"/></param>
         /// <param name="reason">The auditlog reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuild> ModifyCommunitySettingsAsync(bool enabled, DiscordChannel rulesChannel = null, DiscordChannel publicUpdatesChannel = null, string preferredLocale = "en-US", string description = null, DefaultMessageNotifications defaultMessageNotifications = DefaultMessageNotifications.MentionsOnly, string reason = null)
         {
             var verificationLevel = this.VerificationLevel;
             if(this.VerificationLevel != VerificationLevel.Highest)
             {
                 verificationLevel = VerificationLevel.High;
             }
 
             var explicitContentFilter = ExplicitContentFilter.AllMembers;
 
             var rulesChannelId = Optional.FromNoValue<ulong?>();
             if (rulesChannel != null && rulesChannel.Type != ChannelType.Text && rulesChannel.Type != ChannelType.News)
                 throw new ArgumentException("Rules channel needs to be a text channel.");
             else if (rulesChannel != null)
                 rulesChannelId = rulesChannel.Id;
             else if (rulesChannel == null)
                 rulesChannelId = null;
 
             var publicUpdatesChannelId = Optional.FromNoValue<ulong?>();
             if (publicUpdatesChannel != null && publicUpdatesChannel.Type != ChannelType.Text && publicUpdatesChannel.Type != ChannelType.News)
                 throw new ArgumentException("Public updates channel needs to be a text channel.");
             else if (publicUpdatesChannel != null)
                 publicUpdatesChannelId = publicUpdatesChannel.Id;
             else if (publicUpdatesChannel == null)
                 publicUpdatesChannelId = null;
 
             List<string> features = new();
             var rfeatures = this.RawFeatures.ToList();
             if (this.RawFeatures.Contains("COMMUNITY") && enabled)
             {
                 features = rfeatures;
             } else if(!this.RawFeatures.Contains("COMMUNITY") && enabled)
             {
                 rfeatures.Add("COMMUNITY");
                 features = rfeatures;
             }
             else if (this.RawFeatures.Contains("COMMUNITY") && !enabled)
             {
                 rfeatures.Remove("COMMUNITY");
                 features = rfeatures;
             } else if(!this.RawFeatures.Contains("COMMUNITY") && !enabled)
             {
                 features = rfeatures;
             }
 
             return await this.Discord.ApiClient.ModifyGuildCommunitySettingsAsync(this.Id, features, rulesChannelId, publicUpdatesChannelId, preferredLocale, description, defaultMessageNotifications, explicitContentFilter, verificationLevel, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Bans a specified member from this guild.
         /// </summary>
         /// <param name="member">Member to ban.</param>
         /// <param name="delete_message_days">How many days to remove messages from.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanMemberAsync(DiscordMember member, int delete_message_days = 0, string reason = null)
             => this.Discord.ApiClient.CreateGuildBanAsync(this.Id, member.Id, delete_message_days, reason);
 
         /// <summary>
         /// Bans a specified user by ID. This doesn't require the user to be in this guild.
         /// </summary>
         /// <param name="user_id">ID of the user to ban.</param>
         /// <param name="delete_message_days">How many days to remove messages from.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task BanMemberAsync(ulong user_id, int delete_message_days = 0, string reason = null)
             => this.Discord.ApiClient.CreateGuildBanAsync(this.Id, user_id, delete_message_days, reason);
 
         /// <summary>
         /// Unbans a user from this guild.
         /// </summary>
         /// <param name="user">User to unban.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanMemberAsync(DiscordUser user, string reason = null)
             => this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user.Id, reason);
 
         /// <summary>
         /// Unbans a user by ID.
         /// </summary>
         /// <param name="user_id">ID of the user to unban.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnbanMemberAsync(ulong user_id, string reason = null)
             => this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user_id, reason);
 
         /// <summary>
         /// Leaves this guild.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task LeaveAsync()
             => this.Discord.ApiClient.LeaveGuildAsync(this.Id);
 
         /// <summary>
         /// Gets the bans for this guild.
         /// </summary>
         /// <returns>Collection of bans in this guild.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordBan>> GetBansAsync()
             => this.Discord.ApiClient.GetGuildBansAsync(this.Id);
 
         /// <summary>
         /// Gets a ban for a specific user.
         /// </summary>
         /// <param name="userId">The Id of the user to get the ban for.</param>
         /// <exception cref="NotFoundException">Thrown when the specified user is not banned.</exception>
         /// <returns>The requested ban object.</returns>
         public Task<DiscordBan> GetBanAsync(ulong userId)
             => this.Discord.ApiClient.GetGuildBanAsync(this.Id, userId);
 
         /// <summary>
         /// Gets a ban for a specific user.
         /// </summary>
         /// <param name="user">The user to get the ban for.</param>
         /// <exception cref="NotFoundException">Thrown when the specified user is not banned.</exception>
         /// <returns>The requested ban object.</returns>
         public Task<DiscordBan> GetBanAsync(DiscordUser user)
             => this.GetBanAsync(user.Id);
 
         #region Sheduled Events
 
         /// <summary>
         /// Creates a scheduled event.
         /// </summary>
         /// <param name="name">The name.</param>
         /// <param name="privacy_level">The privacy level.</param>
         /// <param name="scheduled_start_time">The scheduled start time.</param>
         /// <param name="scheduled_end_time">The scheduled end time.</param>
         /// <param name="channel">The channel.</param>
         /// <param name="metadata">The metadata.</param>
         /// <param name="description">The description.</param>
         /// <param name="type">The type.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A scheduled event.</returns>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, ScheduledEventPrivacyLevel privacy_level, DateTimeOffset scheduled_start_time, DateTimeOffset? scheduled_end_time = null, DiscordChannel channel = null, DiscordScheduledEventEntityMetadata metadata = null, string description = null, ScheduledEventEntityType type = ScheduledEventEntityType.StageInstance, string reason = null)
             => await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, channel?.Id, metadata, name, privacy_level, scheduled_start_time, scheduled_end_time.HasValue && type == ScheduledEventEntityType.External ? scheduled_end_time.Value : null, description, type, reason);
 
         /// <summary>
         /// Creates a scheduled event with type <see cref="ScheduledEventEntityType.External"/>.
         /// </summary>
         /// <param name="name">The name.</param>
         /// <param name="privacy_level">The privacy level.</param>
         /// <param name="scheduled_start_time">The scheduled start time.</param>
         /// <param name="scheduled_end_time">The scheduled end time.</param>
         /// <param name="location">The location of the external event.</param>
         /// <param name="description">The description.</param>
         /// <param name="reason">The reason.</param>
         /// <returns>A scheduled event.</returns>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordScheduledEvent> CreateExternalScheduledEventAsync(string name, ScheduledEventPrivacyLevel privacy_level, DateTimeOffset scheduled_start_time, DateTimeOffset scheduled_end_time, string location, string description = null, string reason = null)
             => await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, null, new DiscordScheduledEventEntityMetadata(location), name, privacy_level, scheduled_start_time, scheduled_end_time, description, ScheduledEventEntityType.External, reason);
 
 
         /// <summary>
         /// Gets a specific scheduled events.
         /// </summary>
         /// <param name="sheduled_event_id">The Id of the event to get.</param>
+        /// <param name="with_user_count">Whether to include user count.</param>
         /// <returns>A scheduled event.</returns>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-        public async Task<DiscordScheduledEvent> GetScheduledEventAsync(ulong sheduled_event_id)
-            => await this.Discord.ApiClient.GetGuildScheduledEventAsync(this.Id, sheduled_event_id);
+        public async Task<DiscordScheduledEvent> GetScheduledEventAsync(ulong sheduled_event_id, bool? with_user_count = null)
+            => await this.Discord.ApiClient.GetGuildScheduledEventAsync(this.Id, sheduled_event_id, with_user_count);
 
         /// <summary>
         /// Gets a specific scheduled events.
         /// </summary>
         /// <param name="sheduled_event">The event to get.</param>
+        /// <param name="with_user_count">Whether to include user count.</param>
         /// <returns>A sheduled event.</returns>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-        public async Task<DiscordScheduledEvent> GetScheduledEventAsync(DiscordScheduledEvent sheduled_event)
-            => await this.GetScheduledEventAsync(sheduled_event.Id);
+        public async Task<DiscordScheduledEvent> GetScheduledEventAsync(DiscordScheduledEvent sheduled_event, bool? with_user_count = null)
+            => await this.GetScheduledEventAsync(sheduled_event.Id, with_user_count);
 
         /// <summary>
         /// Gets the guilds scheduled events.
         /// </summary>
+        /// <param name="with_user_count">Whether to include user count.</param>
         /// <returns>A list of the guilds scheduled events.</returns>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> GetScheduledEventsAsync(bool? with_user_count = null)
             => await this.Discord.ApiClient.ListGuildScheduledEventsAsync(this.Id, with_user_count);
         #endregion
 
         /// <summary>
         /// Creates a new text channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new channel.</param>
         /// <param name="parent">Category to put this channel in.</param>
         /// <param name="topic">Topic of the channel.</param>
         /// <param name="overwrites">Permission overwrites for this channel.</param>
         /// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <param name="perUserRateLimit">Slow mode timeout for users.</param>
         /// <returns>The newly-created channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateTextChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Text, parent, topic, null, null, overwrites, nsfw, perUserRateLimit, null, reason);
 
         /// <summary>
         /// Creates a new channel category in this guild.
         /// </summary>
         /// <param name="name">Name of the new category.</param>
         /// <param name="overwrites">Permission overwrites for this category.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created channel category.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateChannelCategoryAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Category, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, reason);
 
         /// <summary>
         /// Creates a new stage channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new stage channel.</param>
         /// <param name="overwrites">Permission overwrites for this stage channel.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created stage channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="NotSupportedException">Thrown when the guilds has not enabled community.</exception>
         public Task<DiscordChannel> CreateStageChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.Stage, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a stage channel.");
 
         /// <summary>
         /// Creates a new news channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new stage channel.</param>
         /// <param name="overwrites">Permission overwrites for this news channel.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created news channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="NotSupportedException">Thrown when the guilds has not enabled community.</exception>
         public Task<DiscordChannel> CreateNewsChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
             => this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.News, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a news channel.");
 
         /// <summary>
         /// Creates a new voice channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new channel.</param>
         /// <param name="parent">Category to put this channel in.</param>
         /// <param name="bitrate">Bitrate of the channel.</param>
         /// <param name="user_limit">Maximum number of users in the channel.</param>
         /// <param name="overwrites">Permission overwrites for this channel.</param>
         /// <param name="qualityMode">Video quality mode of the channel.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateVoiceChannelAsync(string name, DiscordChannel parent = null, int? bitrate = null, int? user_limit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, VideoQualityMode? qualityMode = null, string reason = null)
             => this.CreateChannelAsync(name, ChannelType.Voice, parent, Optional.FromNoValue<string>(), bitrate, user_limit, overwrites, null, Optional.FromNoValue<int?>(), qualityMode, reason);
 
         /// <summary>
         /// Creates a new channel in this guild.
         /// </summary>
         /// <param name="name">Name of the new channel.</param>
         /// <param name="type">Type of the new channel.</param>
         /// <param name="parent">Category to put this channel in.</param>
         /// <param name="topic">Topic of the channel.</param>
         /// <param name="bitrate">Bitrate of the channel. Applies to voice only.</param>
         /// <param name="userLimit">Maximum number of users in the channel. Applies to voice only.</param>
         /// <param name="overwrites">Permission overwrites for this channel.</param>
         /// <param name="nsfw">Whether the channel is to be flagged as not safe for work. Applies to text only.</param>
         /// <param name="perUserRateLimit">Slow mode timeout for users.</param>
         /// <param name="qualityMode">Video quality mode of the channel. Applies to voice only.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, string reason = null)
         {
             // technically you can create news/store channels but not always
             return type != ChannelType.Text && type != ChannelType.Voice && type != ChannelType.Category && type != ChannelType.News && type != ChannelType.Store && type != ChannelType.Stage
                 ? throw new ArgumentException("Channel type must be text, voice, stage, or category.", nameof(type))
                 : type == ChannelType.Category && parent != null
                 ? throw new ArgumentException("Cannot specify parent of a channel category.", nameof(parent))
                 : this.Discord.ApiClient.CreateGuildChannelAsync(this.Id, name, type, parent?.Id, topic, bitrate, userLimit, overwrites, nsfw, perUserRateLimit, qualityMode, reason);
         }
 
         /// <summary>
         /// Gets active threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordThreadResult> GetActiveThreadsAsync()
             => this.Discord.ApiClient.GetActiveThreadsAsync(this.Id);
 
         // this is to commemorate the Great DAPI Channel Massacre of 2017-11-19.
         /// <summary>
         /// <para>Deletes all channels in this guild.</para>
         /// <para>Note that this is irreversible. Use carefully!</para>
         /// </summary>
         /// <returns></returns>
         public Task DeleteAllChannelsAsync()
         {
             var tasks = this.Channels.Values.Select(xc => xc.DeleteAsync());
             return Task.WhenAll(tasks);
         }
 
         /// <summary>
         /// Estimates the number of users to be pruned.
         /// </summary>
         /// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
         /// <param name="includedRoles">The roles to be included in the prune.</param>
         /// <returns>Number of users that will be pruned.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<int> GetPruneCountAsync(int days = 7, IEnumerable<DiscordRole> includedRoles = null)
         {
             if (includedRoles != null)
             {
                 includedRoles = includedRoles.Where(r => r != null);
                 var roleCount = includedRoles.Count();
                 var roleArr = includedRoles.ToArray();
                 var rawRoleIds = new List<ulong>();
 
                 for (var i = 0; i < roleCount; i++)
                 {
                     if (this._roles.ContainsKey(roleArr[i].Id))
                         rawRoleIds.Add(roleArr[i].Id);
                 }
 
                 return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, rawRoleIds);
             }
 
             return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, null);
         }
 
         /// <summary>
         /// Prunes inactive users from this guild.
         /// </summary>
         /// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
         /// <param name="computePruneCount">Whether to return the prune count after this method completes. This is discouraged for larger guilds.</param>
         /// <param name="includedRoles">The roles to be included in the prune.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>Number of users pruned.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<int?> PruneAsync(int days = 7, bool computePruneCount = true, IEnumerable<DiscordRole> includedRoles = null, string reason = null)
         {
             if (includedRoles != null)
             {
                 includedRoles = includedRoles.Where(r => r != null);
                 var roleCount = includedRoles.Count();
                 var roleArr = includedRoles.ToArray();
                 var rawRoleIds = new List<ulong>();
 
                 for (var i = 0; i < roleCount; i++)
                 {
                     if (this._roles.ContainsKey(roleArr[i].Id))
                         rawRoleIds.Add(roleArr[i].Id);
                 }
 
                 return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, rawRoleIds, reason);
             }
 
             return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, null, reason);
         }
 
         /// <summary>
         /// Gets integrations attached to this guild.
         /// </summary>
         /// <returns>Collection of integrations attached to this guild.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordIntegration>> GetIntegrationsAsync()
             => this.Discord.ApiClient.GetGuildIntegrationsAsync(this.Id);
 
         /// <summary>
         /// Attaches an integration from current user to this guild.
         /// </summary>
         /// <param name="integration">Integration to attach.</param>
         /// <returns>The integration after being attached to the guild.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordIntegration> AttachUserIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.CreateGuildIntegrationAsync(this.Id, integration.Type, integration.Id);
 
         /// <summary>
         /// Modifies an integration in this guild.
         /// </summary>
         /// <param name="integration">Integration to modify.</param>
         /// <param name="expire_behaviour">Number of days after which the integration expires.</param>
         /// <param name="expire_grace_period">Length of grace period which allows for renewing the integration.</param>
         /// <param name="enable_emoticons">Whether emotes should be synced from this integration.</param>
         /// <returns>The modified integration.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordIntegration> ModifyIntegrationAsync(DiscordIntegration integration, int expire_behaviour, int expire_grace_period, bool enable_emoticons)
             => this.Discord.ApiClient.ModifyGuildIntegrationAsync(this.Id, integration.Id, expire_behaviour, expire_grace_period, enable_emoticons);
 
         /// <summary>
         /// Removes an integration from this guild.
         /// </summary>
         /// <param name="integration">Integration to remove.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.DeleteGuildIntegrationAsync(this.Id, integration);
 
         /// <summary>
         /// Forces re-synchronization of an integration for this guild.
         /// </summary>
         /// <param name="integration">Integration to synchronize.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task SyncIntegrationAsync(DiscordIntegration integration)
             => this.Discord.ApiClient.SyncGuildIntegrationAsync(this.Id, integration.Id);
 
         /// <summary>
         /// Gets the voice regions for this guild.
         /// </summary>
         /// <returns>Voice regions available for this guild.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
         {
             var vrs = await this.Discord.ApiClient.GetGuildVoiceRegionsAsync(this.Id).ConfigureAwait(false);
             foreach (var xvr in vrs)
                 this.Discord.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 
             return vrs;
         }
 
         /// <summary>
         /// Gets an invite from this guild from an invite code.
         /// </summary>
         /// <param name="code">The invite code</param>
         /// <returns>An invite, or null if not in cache.</returns>
         public DiscordInvite GetInvite(string code)
             => this._invites.TryGetValue(code, out var invite) ? invite : null;
 
         /// <summary>
         /// Gets all the invites created for all the channels in this guild.
         /// </summary>
         /// <returns>A collection of invites.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
         {
             var res = await this.Discord.ApiClient.GetGuildInvitesAsync(this.Id).ConfigureAwait(false);
 
             var intents = this.Discord.Configuration.Intents;
 
             if (!intents.HasIntent(DiscordIntents.GuildInvites))
             {
                 for (var i = 0; i < res.Count; i++)
                     this._invites[res[i].Code] = res[i];
             }
 
             return res;
         }
 
         /// <summary>
         /// Gets the vanity invite for this guild.
         /// </summary>
         /// <returns>A partial vanity invite.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordInvite> GetVanityInviteAsync()
             => this.Discord.ApiClient.GetGuildVanityUrlAsync(this.Id);
 
         /// <summary>
         /// Gets all the webhooks created for all the channels in this guild.
         /// </summary>
         /// <returns>A collection of webhooks this guild has.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
             => this.Discord.ApiClient.GetGuildWebhooksAsync(this.Id);
 
         /// <summary>
         /// Gets this guild's widget image.
         /// </summary>
         /// <param name="bannerType">The format of the widget.</param>
         /// <returns>The URL of the widget image.</returns>
         public string GetWidgetImage(WidgetType bannerType = WidgetType.Shield)
         {
             var param = bannerType switch
             {
                 WidgetType.Banner1 => "banner1",
                 WidgetType.Banner2 => "banner2",
                 WidgetType.Banner3 => "banner3",
                 WidgetType.Banner4 => "banner4",
                 _ => "shield",
             };
             return $"{Endpoints.BASE_URI}{Endpoints.GUILDS}/{this.Id}{Endpoints.WIDGET_PNG}?style={param}";
         }
 
         /// <summary>
         /// Gets a member of this guild by their user ID.
         /// </summary>
         /// <param name="userId">ID of the member to get.</param>
         /// <returns>The requested member.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordMember> GetMemberAsync(ulong userId)
         {
             if (this._members != null && this._members.TryGetValue(userId, out var mbr))
                 return mbr;
 
             mbr = await this.Discord.ApiClient.GetGuildMemberAsync(this.Id, userId).ConfigureAwait(false);
 
             var intents = this.Discord.Configuration.Intents;
 
             if (intents.HasIntent(DiscordIntents.GuildMembers))
             {
                 if (this._members != null)
                 {
                     this._members[userId] = mbr;
                 }
             }
 
             return mbr;
         }
 
         /// <summary>
         /// Retrieves a full list of members from Discord. This method will bypass cache.
         /// </summary>
         /// <returns>A collection of all members in this guild.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyCollection<DiscordMember>> GetAllMembersAsync()
         {
             var recmbr = new HashSet<DiscordMember>();
 
             var recd = 1000;
             var last = 0ul;
             while (recd > 0)
             {
                 var tms = await this.Discord.ApiClient.ListGuildMembersAsync(this.Id, 1000, last == 0 ? null : (ulong?)last).ConfigureAwait(false);
                 recd = tms.Count;
 
                 foreach (var xtm in tms)
                 {
                     var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
                     usr = this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
                     {
                         old.Username = usr.Username;
                         old.Discord = usr.Discord;
                         old.AvatarHash = usr.AvatarHash;
 
                         return old;
                     });
 
                     recmbr.Add(new DiscordMember(xtm) { Discord = this.Discord, _guild_id = this.Id });
                 }
 
                 var tm = tms.LastOrDefault();
                 last = tm?.User.Id ?? 0;
             }
 
             return new ReadOnlySet<DiscordMember>(recmbr);
         }
 
         /// <summary>
         /// Requests that Discord send a list of guild members based on the specified arguments. This method will fire the <see cref="DiscordClient.GuildMembersChunked"/> event.
         /// <para>If no arguments aside from <paramref name="presences"/> and <paramref name="nonce"/> are specified, this will request all guild members.</para>
         /// </summary>
         /// <param name="query">Filters the returned members based on what the username starts with. Either this or <paramref name="userIds"/> must not be null.
         /// The <paramref name="limit"/> must also be greater than 0 if this is specified.</param>
         /// <param name="limit">Total number of members to request. This must be greater than 0 if <paramref name="query"/> is specified.</param>
         /// <param name="presences">Whether to include the <see cref="GuildMembersChunkEventArgs.Presences"/> associated with the fetched members.</param>
         /// <param name="userIds">Whether to limit the request to the specified user ids. Either this or <paramref name="query"/> must not be null.</param>
         /// <param name="nonce">The unique string to identify the response.</param>
         public async Task RequestMembersAsync(string query = "", int limit = 0, bool? presences = null, IEnumerable<ulong> userIds = null, string nonce = null)
         {
             if (this.Discord is not DiscordClient client)
                 throw new InvalidOperationException("This operation is only valid for regular Discord clients.");
 
             if (query == null && userIds == null)
                 throw new ArgumentException("The query and user IDs cannot both be null.");
 
             if (query != null && userIds != null)
                 query = null;
 
             var grgm = new GatewayRequestGuildMembers(this)
             {
                 Query = query,
                 Limit = limit >= 0 ? limit : 0,
                 Presences = presences,
                 UserIds = userIds,
                 Nonce = nonce
             };
 
             var payload = new GatewayPayload
             {
                 OpCode = GatewayOpCode.RequestGuildMembers,
                 Data = grgm
             };
 
             var payloadStr = JsonConvert.SerializeObject(payload, Formatting.None);
             await client.WsSendAsync(payloadStr).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets all the channels this guild has.
         /// </summary>
         /// <returns>A collection of this guild's channels.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordChannel>> GetChannelsAsync()
             => this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
         /// <summary>
         /// Creates a new role in this guild.
         /// </summary>
         /// <param name="name">Name of the role.</param>
         /// <param name="permissions">Permissions for the role.</param>
         /// <param name="color">Color for the role.</param>
         /// <param name="hoist">Whether the role is to be hoisted.</param>
         /// <param name="mentionable">Whether the role is to be mentionable.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>The newly-created role.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordRole> CreateRoleAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
             => this.Discord.ApiClient.CreateGuildRoleAsync(this.Id, name, permissions, color?.Value, hoist, mentionable, reason);
 
         /// <summary>
         /// Gets a role from this guild by its ID.
         /// </summary>
         /// <param name="id">ID of the role to get.</param>
         /// <returns>Requested role.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordRole GetRole(ulong id)
             => this._roles.TryGetValue(id, out var role) ? role : null;
 
         /// <summary>
         /// Gets a channel from this guild by its ID.
         /// </summary>
         /// <param name="id">ID of the channel to get.</param>
         /// <returns>Requested channel.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordChannel GetChannel(ulong id)
             => (this._channels != null && this._channels.TryGetValue(id, out var channel)) ? channel : null;
 
         /// <summary>
         /// Gets a thread from this guild by its ID.
         /// </summary>
         /// <param name="id">ID of the thread to get.</param>
         /// <returns>Requested thread.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordThreadChannel GetThread(ulong id)
             => (this._threads != null && this._threads.TryGetValue(id, out var thread)) ? thread : null;
 
         /// <summary>
         /// Gets audit log entries for this guild.
         /// </summary>
         /// <param name="limit">Maximum number of entries to fetch.</param>
         /// <param name="by_member">Filter by member responsible.</param>
         /// <param name="action_type">Filter by action type.</param>
         /// <returns>A collection of requested audit log entries.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember by_member = null, AuditLogActionType? action_type = null)
         {
             var alrs = new List<AuditLog>();
             int ac = 1, tc = 0, rmn = 100;
             var last = 0ul;
             while (ac > 0)
             {
                 rmn = limit != null ? limit.Value - tc : 100;
                 rmn = Math.Min(100, rmn);
                 if (rmn <= 0) break;
 
                 var alr = await this.Discord.ApiClient.GetAuditLogsAsync(this.Id, rmn, null, last == 0 ? null : (ulong?)last, by_member?.Id, (int?)action_type).ConfigureAwait(false);
                 ac = alr.Entries.Count();
                 tc += ac;
                 if (ac > 0)
                 {
                     last = alr.Entries.Last().Id;
                     alrs.Add(alr);
                 }
             }
 
             var amr = alrs.SelectMany(xa => xa.Users)
                 .GroupBy(xu => xu.Id)
                 .Select(xgu => xgu.First());
 
             foreach (var xau in amr)
             {
                 if (this.Discord.UserCache.ContainsKey(xau.Id))
                     continue;
 
                 var xtu = new TransportUser
                 {
                     Id = xau.Id,
                     Username = xau.Username,
                     Discriminator = xau.Discriminator,
                     AvatarHash = xau.AvatarHash
                 };
                 var xu = new DiscordUser(xtu) { Discord = this.Discord };
                 xu = this.Discord.UserCache.AddOrUpdate(xu.Id, xu, (id, old) =>
                 {
                     old.Username = xu.Username;
                     old.Discriminator = xu.Discriminator;
                     old.AvatarHash = xu.AvatarHash;
                     return old;
                 });
             }
 
             var ahr = alrs.SelectMany(xa => xa.Webhooks)
                 .GroupBy(xh => xh.Id)
                 .Select(xgh => xgh.First());
 
             var ams = amr.Select(xau => (this._members != null && this._members.TryGetValue(xau.Id, out var member)) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, _guild_id = this.Id });
             var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
             Dictionary<ulong, DiscordWebhook> ahd = null;
             if (ahr.Any())
             {
                 var whr = await this.GetWebhooksAsync().ConfigureAwait(false);
                 var whs = whr.ToDictionary(xh => xh.Id, xh => xh);
 
                 var amh = ahr.Select(xah => whs.TryGetValue(xah.Id, out var webhook) ? webhook : new DiscordWebhook { Discord = this.Discord, Name = xah.Name, Id = xah.Id, AvatarHash = xah.AvatarHash, ChannelId = xah.ChannelId, GuildId = xah.GuildId, Token = xah.Token });
                 ahd = amh.ToDictionary(xh => xh.Id, xh => xh);
             }
 
             var acs = alrs.SelectMany(xa => xa.Entries).OrderByDescending(xa => xa.Id);
             var entries = new List<DiscordAuditLogEntry>();
             foreach (var xac in acs)
             {
                 DiscordAuditLogEntry entry = null;
                 ulong t1, t2;
                 int t3, t4;
                 long t5, t6;
                 bool p1, p2;
                 switch (xac.ActionType)
                 {
                     case AuditLogActionType.GuildUpdate:
                         entry = new DiscordAuditLogGuildEntry
                         {
                             Target = this
                         };
 
                         var entrygld = entry as DiscordAuditLogGuildEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entrygld.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "owner_id":
                                     entrygld.OwnerChange = new PropertyChange<DiscordMember>
                                     {
                                         Before = (this._members != null && this._members.TryGetValue(xc.OldValueUlong, out var oldMember)) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
                                         After = (this._members != null && this._members.TryGetValue(xc.NewValueUlong, out var newMember)) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
                                     };
                                     break;
 
                                 case "icon_hash":
                                     entrygld.IconChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.OldValueString}.webp" : null,
                                         After = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.NewValueString}.webp" : null
                                     };
                                     break;
 
                                 case "verification_level":
                                     entrygld.VerificationLevelChange = new PropertyChange<VerificationLevel>
                                     {
                                         Before = (VerificationLevel)(long)xc.OldValue,
                                         After = (VerificationLevel)(long)xc.NewValue
                                     };
                                     break;
 
                                 case "afk_channel_id":
                                     ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrygld.AfkChannelChange = new PropertyChange<DiscordChannel>
                                     {
                                         Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
                                         After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
                                     };
                                     break;
 
                                 case "widget_channel_id":
                                     ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrygld.EmbedChannelChange = new PropertyChange<DiscordChannel>
                                     {
                                         Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
                                         After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
                                     };
                                     break;
 
                                 case "splash_hash":
                                     entrygld.SplashChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.OldValueString}.webp?size=2048" : null,
                                         After = xc.NewValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.NewValueString}.webp?size=2048" : null
                                     };
                                     break;
 
                                 case "default_message_notifications":
                                     entrygld.NotificationSettingsChange = new PropertyChange<DefaultMessageNotifications>
                                     {
                                         Before = (DefaultMessageNotifications)(long)xc.OldValue,
                                         After = (DefaultMessageNotifications)(long)xc.NewValue
                                     };
                                     break;
 
                                 case "system_channel_id":
                                     ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrygld.SystemChannelChange = new PropertyChange<DiscordChannel>
                                     {
                                         Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
                                         After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
                                     };
                                     break;
 
                                 case "explicit_content_filter":
                                     entrygld.ExplicitContentFilterChange = new PropertyChange<ExplicitContentFilter>
                                     {
                                         Before = (ExplicitContentFilter)(long)xc.OldValue,
                                         After = (ExplicitContentFilter)(long)xc.NewValue
                                     };
                                     break;
 
                                 case "mfa_level":
                                     entrygld.MfaLevelChange = new PropertyChange<MfaLevel>
                                     {
                                         Before = (MfaLevel)(long)xc.OldValue,
                                         After = (MfaLevel)(long)xc.NewValue
                                     };
                                     break;
 
                                 case "region":
                                     entrygld.RegionChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "premium_progress_bar_enabled":
                                     entrygld.PremiumProgressBarChange = new PropertyChange<bool>
                                     {
                                         Before = (bool)xc.OldValue,
                                         After = (bool)xc.NewValue
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.ChannelCreate:
                     case AuditLogActionType.ChannelDelete:
                     case AuditLogActionType.ChannelUpdate:
                         entry = new DiscordAuditLogChannelEntry
                         {
                             Target = this.GetChannel(xac.TargetId.Value) ?? new DiscordChannel { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
                         };
 
                         var entrychn = entry as DiscordAuditLogChannelEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entrychn.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     break;
 
                                 case "type":
                                     p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrychn.TypeChange = new PropertyChange<ChannelType?>
                                     {
                                         Before = p1 ? (ChannelType?)t1 : null,
                                         After = p2 ? (ChannelType?)t2 : null
                                     };
                                     break;
 
                                 case "permission_overwrites":
                                     var olds = xc.OldValues?.OfType<JObject>()
                                         ?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
                                         ?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
                                     var news = xc.NewValues?.OfType<JObject>()
                                         ?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
                                         ?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
                                     entrychn.OverwriteChange = new PropertyChange<IReadOnlyList<DiscordOverwrite>>
                                     {
                                         Before = olds != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(olds)) : null,
                                         After = news != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(news)) : null
                                     };
                                     break;
 
                                 case "topic":
                                     entrychn.TopicChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "nsfw":
                                     entrychn.NsfwChange = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue
                                     };
                                     break;
 
                                 case "bitrate":
                                     entrychn.BitrateChange = new PropertyChange<int?>
                                     {
                                         Before = (int?)(long?)xc.OldValue,
                                         After = (int?)(long?)xc.NewValue
                                     };
                                     break;
 
                                 case "rate_limit_per_user":
                                     entrychn.PerUserRateLimitChange = new PropertyChange<int?>
                                     {
                                         Before = (int?)(long?)xc.OldValue,
                                         After = (int?)(long?)xc.NewValue
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.OverwriteCreate:
                     case AuditLogActionType.OverwriteDelete:
                     case AuditLogActionType.OverwriteUpdate:
                         entry = new DiscordAuditLogOverwriteEntry
                         {
                             Target = this.GetChannel(xac.TargetId.Value)?.PermissionOverwrites.FirstOrDefault(xo => xo.Id == xac.Options.Id),
                             Channel = this.GetChannel(xac.TargetId.Value)
                         };
 
                         var entryovr = entry as DiscordAuditLogOverwriteEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "deny":
                                     p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entryovr.DenyChange = new PropertyChange<Permissions?>
                                     {
                                         Before = p1 ? (Permissions?)t1 : null,
                                         After = p2 ? (Permissions?)t2 : null
                                     };
                                     break;
 
                                 case "allow":
                                     p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entryovr.AllowChange = new PropertyChange<Permissions?>
                                     {
                                         Before = p1 ? (Permissions?)t1 : null,
                                         After = p2 ? (Permissions?)t2 : null
                                     };
                                     break;
 
                                 case "type":
                                     entryovr.TypeChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "id":
                                     p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entryovr.TargetIdChange = new PropertyChange<ulong?>
                                     {
                                         Before = p1 ? (ulong?)t1 : null,
                                         After = p2 ? (ulong?)t2 : null
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.Kick:
                         entry = new DiscordAuditLogKickEntry
                         {
                             Target = amd.TryGetValue(xac.TargetId.Value, out var kickMember) ? kickMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, _guild_id = this.Id }
                         };
                         break;
 
                     case AuditLogActionType.Prune:
                         entry = new DiscordAuditLogPruneEntry
                         {
                             Days = xac.Options.DeleteMemberDays,
                             Toll = xac.Options.MembersRemoved
                         };
                         break;
 
                     case AuditLogActionType.Ban:
                     case AuditLogActionType.Unban:
                         entry = new DiscordAuditLogBanEntry
                         {
                             Target = amd.TryGetValue(xac.TargetId.Value, out var unbanMember) ? unbanMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, _guild_id = this.Id }
                         };
                         break;
 
                     case AuditLogActionType.MemberUpdate:
                     case AuditLogActionType.MemberRoleUpdate:
                         entry = new DiscordAuditLogMemberUpdateEntry
                         {
                             Target = amd.TryGetValue(xac.TargetId.Value, out var roleUpdMember) ? roleUpdMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, _guild_id = this.Id }
                         };
 
                         var entrymbu = entry as DiscordAuditLogMemberUpdateEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "nick":
                                     entrymbu.NicknameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "deaf":
                                     entrymbu.DeafenChange = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue
                                     };
                                     break;
 
                                 case "mute":
                                     entrymbu.MuteChange = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue
                                     };
                                     break;
 
                                 case "$add":
                                     entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
                                     break;
 
                                 case "$remove":
                                     entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.RoleCreate:
                     case AuditLogActionType.RoleDelete:
                     case AuditLogActionType.RoleUpdate:
                         entry = new DiscordAuditLogRoleUpdateEntry
                         {
                             Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entryrol.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "color":
                                     p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
                                     p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
                                     entryrol.ColorChange = new PropertyChange<int?>
                                     {
                                         Before = p1 ? (int?)t3 : null,
                                         After = p2 ? (int?)t4 : null
                                     };
                                     break;
 
                                 case "permissions":
                                     entryrol.PermissionChange = new PropertyChange<Permissions?>
                                     {
                                         Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
                                         After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
                                     };
                                     break;
 
                                 case "position":
                                     entryrol.PositionChange = new PropertyChange<int?>
                                     {
                                         Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
                                         After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
                                     };
                                     break;
 
                                 case "mentionable":
                                     entryrol.MentionableChange = new PropertyChange<bool?>
                                     {
                                         Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
                                         After = xc.NewValue != null ? (bool?)xc.NewValue : null
                                     };
                                     break;
 
                                 case "hoist":
                                     entryrol.HoistChange = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.InviteCreate:
                     case AuditLogActionType.InviteDelete:
                     case AuditLogActionType.InviteUpdate:
                         entry = new DiscordAuditLogInviteEntry();
 
                         var inv = new DiscordInvite
                         {
                             Discord = this.Discord,
                             Guild = new DiscordInviteGuild
                             {
                                 Discord = this.Discord,
                                 Id = this.Id,
                                 Name = this.Name,
                                 SplashHash = this.SplashHash
                             }
                         };
 
                         var entryinv = entry as DiscordAuditLogInviteEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "max_age":
                                     p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
                                     p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
                                     entryinv.MaxAgeChange = new PropertyChange<int?>
                                     {
                                         Before = p1 ? (int?)t3 : null,
                                         After = p2 ? (int?)t4 : null
                                     };
                                     break;
 
                                 case "code":
                                     inv.Code = xc.OldValueString ?? xc.NewValueString;
 
                                     entryinv.CodeChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "temporary":
                                     entryinv.TemporaryChange = new PropertyChange<bool?>
                                     {
                                         Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
                                         After = xc.NewValue != null ? (bool?)xc.NewValue : null
                                     };
                                     break;
 
                                 case "inviter_id":
                                     p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entryinv.InviterChange = new PropertyChange<DiscordMember>
                                     {
                                         Before = amd.TryGetValue(t1, out var propBeforeMember) ? propBeforeMember : new DiscordMember { Id = t1, Discord = this.Discord, _guild_id = this.Id },
                                         After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, _guild_id = this.Id },
                                     };
                                     break;
 
                                 case "channel_id":
                                     p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entryinv.ChannelChange = new PropertyChange<DiscordChannel>
                                     {
                                         Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
                                         After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
                                     };
 
                                     var ch = entryinv.ChannelChange.Before ?? entryinv.ChannelChange.After;
                                     var cht = ch?.Type;
                                     inv.Channel = new DiscordInviteChannel
                                     {
                                         Discord = this.Discord,
                                         Id = p1 ? t1 : t2,
                                         Name = ch?.Name,
                                         Type = cht != null ? cht.Value : ChannelType.Unknown
                                     };
                                     break;
 
                                 case "uses":
                                     p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
                                     p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
                                     entryinv.UsesChange = new PropertyChange<int?>
                                     {
                                         Before = p1 ? (int?)t3 : null,
                                         After = p2 ? (int?)t4 : null
                                     };
                                     break;
 
                                 case "max_uses":
                                     p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
                                     p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
                                     entryinv.MaxUsesChange = new PropertyChange<int?>
                                     {
                                         Before = p1 ? (int?)t3 : null,
                                         After = p2 ? (int?)t4 : null
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
 
                         entryinv.Target = inv;
                         break;
 
                     case AuditLogActionType.WebhookCreate:
                     case AuditLogActionType.WebhookDelete:
                     case AuditLogActionType.WebhookUpdate:
                         entry = new DiscordAuditLogWebhookEntry
                         {
                             Target = ahd.TryGetValue(xac.TargetId.Value, out var webhook) ? webhook : new DiscordWebhook { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entrywhk = entry as DiscordAuditLogWebhookEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entrywhk.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 case "channel_id":
                                     p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrywhk.ChannelChange = new PropertyChange<DiscordChannel>
                                     {
                                         Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
                                         After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
                                     };
                                     break;
 
                                 case "type": // ???
                                     p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
                                     p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
                                     entrywhk.TypeChange = new PropertyChange<int?>
                                     {
                                         Before = p1 ? (int?)t3 : null,
                                         After = p2 ? (int?)t4 : null
                                     };
                                     break;
 
                                 case "avatar_hash":
                                     entrywhk.AvatarHashChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.EmojiCreate:
                     case AuditLogActionType.EmojiDelete:
                     case AuditLogActionType.EmojiUpdate:
                         entry = new DiscordAuditLogEmojiEntry
                         {
                             Target = this._emojis.TryGetValue(xac.TargetId.Value, out var target) ? target : new DiscordEmoji { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entryemo = entry as DiscordAuditLogEmojiEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entryemo.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.StageInstanceCreate:
                     case AuditLogActionType.StageInstanceDelete:
                     case AuditLogActionType.StageInstanceUpdate:
                         entry = new DiscordAuditLogStageEntry
                         {
                             Target = this._stageInstances.TryGetValue(xac.TargetId.Value, out var stage) ? stage : new DiscordStageInstance { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entrysta = entry as DiscordAuditLogStageEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "topic":
                                     entrysta.TopicChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
                                 case "privacy_level":
                                     entrysta.PrivacyLevelChange = new PropertyChange<StagePrivacyLevel?>
                                     {
                                         Before = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5) ? (StagePrivacyLevel?)t5 : null,
                                         After = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6) ? (StagePrivacyLevel?)t6 : null,
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.StickerCreate:
                     case AuditLogActionType.StickerDelete:
                     case AuditLogActionType.StickerUpdate:
                         entry = new DiscordAuditLogStickerEntry
                         {
                             Target = this._stickers.TryGetValue(xac.TargetId.Value, out var sticker) ? sticker : new DiscordSticker { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entrysti = entry as DiscordAuditLogStickerEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entrysti.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
                                 case "description":
                                     entrysti.DescriptionChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
                                 case "tags":
                                     entrysti.TagsChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
                                 case "guild_id":
                                     entrysti.GuildIdChange = new PropertyChange<ulong?>
                                     {
                                         Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
                                         After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
                                     };
                                     break;
                                 case "available":
                                     entrysti.AvailabilityChange = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue,
                                     };
                                     break;
                                 case "asset":
                                     entrysti.AssetChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValueString,
                                         After = xc.NewValueString
                                     };
                                     break;
                                 case "id":
                                     entrysti.IdChange = new PropertyChange<ulong?>
                                     {
                                         Before = ulong.TryParse(xc.OldValueString, out var oid) ? oid : null,
                                         After = ulong.TryParse(xc.NewValueString, out var nid) ? nid : null
                                     };
                                     break;
                                 case "type":
                                     p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
                                     p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
                                     entrysti.TypeChange = new PropertyChange<StickerType?>
                                     {
                                         Before = p1 ? (StickerType?)t5 : null,
                                         After = p2 ? (StickerType?)t6 : null
                                     };
                                     break;
                                 case "format_type":
                                     p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
                                     p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
                                     entrysti.FormatChange = new PropertyChange<StickerFormat?>
                                     {
                                         Before = p1 ? (StickerFormat?)t5 : null,
                                         After = p2 ? (StickerFormat?)t6 : null
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
 
 
                     case AuditLogActionType.MessageDelete:
                     case AuditLogActionType.MessageBulkDelete:
                     {
                         entry = new DiscordAuditLogMessageEntry();
 
                         var entrymsg = entry as DiscordAuditLogMessageEntry;
 
                         if (xac.Options != null)
                         {
                             entrymsg.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
                             entrymsg.MessageCount = xac.Options.Count;
                         }
 
                         if (entrymsg.Channel != null)
                         {
                             entrymsg.Target = this.Discord is DiscordClient dc
                                 && dc.MessageCache != null
                                 && dc.MessageCache.TryGet(xm => xm.Id == xac.TargetId.Value && xm.ChannelId == entrymsg.Channel.Id, out var msg)
                                 ? msg
                                 : new DiscordMessage { Discord = this.Discord, Id = xac.TargetId.Value };
                         }
                         break;
                     }
 
                     case AuditLogActionType.MessagePin:
                     case AuditLogActionType.MessageUnpin:
                     {
                         entry = new DiscordAuditLogMessagePinEntry();
 
                         var entrypin = entry as DiscordAuditLogMessagePinEntry;
 
                         if (this.Discord is not DiscordClient dc)
                         {
                             break;
                         }
 
                         if (xac.Options != null)
                         {
                             DiscordMessage message = default;
                             dc.MessageCache?.TryGet(x => x.Id == xac.Options.MessageId && x.ChannelId == xac.Options.ChannelId, out message);
 
                             entrypin.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
                             entrypin.Message = message ?? new DiscordMessage { Id = xac.Options.MessageId, Discord = this.Discord };
                         }
 
                         if (xac.TargetId.HasValue)
                         {
                             dc.UserCache.TryGetValue(xac.TargetId.Value, out var user);
                             entrypin.Target = user ?? new DiscordUser { Id = user.Id, Discord = this.Discord };
                         }
 
                         break;
                     }
 
                     case AuditLogActionType.BotAdd:
                     {
                         entry = new DiscordAuditLogBotAddEntry();
 
                         if (!(this.Discord is DiscordClient dc && xac.TargetId.HasValue))
                         {
                             break;
                         }
 
                         dc.UserCache.TryGetValue(xac.TargetId.Value, out var bot);
                         (entry as DiscordAuditLogBotAddEntry).TargetBot = bot ?? new DiscordUser { Id = xac.TargetId.Value, Discord = this.Discord };
 
                         break;
                     }
 
                     case AuditLogActionType.MemberMove:
                         entry = new DiscordAuditLogMemberMoveEntry();
 
                         if (xac.Options == null)
                         {
                             break;
                         }
 
                         var moveentry = entry as DiscordAuditLogMemberMoveEntry;
 
                         moveentry.UserCount = xac.Options.Count;
                         moveentry.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
                         break;
 
                     case AuditLogActionType.MemberDisconnect:
                         entry = new DiscordAuditLogMemberDisconnectEntry
                         {
                             UserCount = xac.Options?.Count ?? 0
                         };
                         break;
 
                     case AuditLogActionType.IntegrationCreate:
                     case AuditLogActionType.IntegrationDelete:
                     case AuditLogActionType.IntegrationUpdate:
                         entry = new DiscordAuditLogIntegrationEntry();
 
                         var integentry = entry as DiscordAuditLogIntegrationEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "enable_emoticons":
                                     integentry.EnableEmoticons = new PropertyChange<bool?>
                                     {
                                         Before = (bool?)xc.OldValue,
                                         After = (bool?)xc.NewValue
                                     };
                                     break;
                                 case "expire_behavior":
                                     integentry.ExpireBehavior = new PropertyChange<int?>
                                     {
                                         Before = (int?)xc.OldValue,
                                         After = (int?)xc.NewValue
                                     };
                                     break;
                                 case "expire_grace_period":
                                     integentry.ExpireBehavior = new PropertyChange<int?>
                                     {
                                         Before = (int?)xc.OldValue,
                                         After = (int?)xc.NewValue
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     case AuditLogActionType.ThreadCreate:
                     case AuditLogActionType.ThreadDelete:
                     case AuditLogActionType.ThreadUpdate:
                         entry = new DiscordAuditLogThreadEntry
                         {
                             Target = this._threads.TryGetValue(xac.TargetId.Value, out var thread) ? thread : new DiscordThreadChannel { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entrythr = entry as DiscordAuditLogThreadEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "name":
                                     entrythr.NameChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     break;
 
                                 case "type":
                                     p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
                                     p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
                                     entrythr.TypeChange = new PropertyChange<ChannelType?>
                                     {
                                         Before = p1 ? (ChannelType?)t1 : null,
                                         After = p2 ? (ChannelType?)t2 : null
                                     };
                                     break;
 
                                 case "archived":
                                     entrythr.ArchivedChange = new PropertyChange<bool?>
                                     {
                                         Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
                                         After = xc.NewValue != null ? (bool?)xc.NewValue : null
                                     };
                                     break;
 
                                 case "locked":
                                     entrythr.LockedChange = new PropertyChange<bool?>
                                     {
                                         Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
                                         After = xc.NewValue != null ? (bool?)xc.NewValue : null
                                     };
                                     break;
 
                                 case "auto_archive_duration":
                                     p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
                                     p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
                                     entrythr.AutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
                                     {
                                         Before = p1 ? (ThreadAutoArchiveDuration?)t5 : null,
                                         After = p2 ? (ThreadAutoArchiveDuration?)t6 : null
                                     };
                                     break;
 
                                 case "rate_limit_per_user":
                                     entrythr.PerUserRateLimitChange = new PropertyChange<int?>
                                     {
                                         Before = (int?)(long?)xc.OldValue,
                                         After = (int?)(long?)xc.NewValue
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
 
                     case AuditLogActionType.GuildScheduledEventCreate:
                     case AuditLogActionType.GuildScheduledEventDelete:
                     case AuditLogActionType.GuildScheduledEventUpdate:
                         entry = new DiscordAuditLogGuildScheduledEventEntry
                         {
                             Target = this._scheduledEvents.TryGetValue(xac.TargetId.Value, out var scheduled_event) ? scheduled_event : new DiscordScheduledEvent { Id = xac.TargetId.Value, Discord = this.Discord }
                         };
 
                         var entryse = entry as DiscordAuditLogGuildScheduledEventEntry;
                         foreach (var xc in xac.Changes)
                         {
                             switch (xc.Key.ToLowerInvariant())
                             {
                                 case "channel_id":
                                     entryse.ChannelIdChange = new PropertyChange<ulong?>
                                     {
                                         Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
                                         After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
                                     };
                                     break;
 
                                 case "description":
                                     entryse.DescriptionChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     break;
 
                                 case "location":
                                     entryse.LocationChange = new PropertyChange<string>
                                     {
                                         Before = xc.OldValue != null ? xc.OldValueString : null,
                                         After = xc.NewValue != null ? xc.NewValueString : null
                                     };
                                     break;
 
                                 case "privacy_level":
                                     p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
                                     p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
                                     entryse.PrivacyLevelChange = new PropertyChange<ScheduledEventPrivacyLevel?>
                                     {
                                         Before = p1 ? (ScheduledEventPrivacyLevel?)t5 : null,
                                         After = p2 ? (ScheduledEventPrivacyLevel?)t6 : null
                                     };
                                     break;
 
                                 case "entity_type":
                                     p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
                                     p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
                                     entryse.EntityTypeChange = new PropertyChange<ScheduledEventEntityType?>
                                     {
                                         Before = p1 ? (ScheduledEventEntityType?)t5 : null,
                                         After = p2 ? (ScheduledEventEntityType?)t6 : null
                                     };
                                     break;
 
                                 case "status":
                                     p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
                                     p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
                                     entryse.StatusChange = new PropertyChange<ScheduledEventStatus?>
                                     {
                                         Before = p1 ? (ScheduledEventStatus?)t5 : null,
                                         After = p2 ? (ScheduledEventStatus?)t6 : null
                                     };
                                     break;
 
                                 default:
                                     this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {0} - this should be reported to library developers", xc.Key);
                                     break;
                             }
                         }
                         break;
 
                     default:
                         this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {0} - this should be reported to library developers", (int)xac.ActionType);
                         break;
                 }
 
                 if (entry == null)
                     continue;
 
                 entry.ActionCategory = xac.ActionType switch
                 {
                     AuditLogActionType.ChannelCreate or AuditLogActionType.EmojiCreate or AuditLogActionType.InviteCreate or AuditLogActionType.OverwriteCreate or AuditLogActionType.RoleCreate or AuditLogActionType.WebhookCreate or AuditLogActionType.IntegrationCreate or AuditLogActionType.StickerCreate or AuditLogActionType.StageInstanceCreate or AuditLogActionType.ThreadCreate or AuditLogActionType.GuildScheduledEventCreate => AuditLogActionCategory.Create,
                     AuditLogActionType.ChannelDelete or AuditLogActionType.EmojiDelete or AuditLogActionType.InviteDelete or AuditLogActionType.MessageDelete or AuditLogActionType.MessageBulkDelete or AuditLogActionType.OverwriteDelete or AuditLogActionType.RoleDelete or AuditLogActionType.WebhookDelete or AuditLogActionType.IntegrationDelete or AuditLogActionType.StickerDelete or AuditLogActionType.StageInstanceDelete or AuditLogActionType.ThreadDelete or AuditLogActionType.GuildScheduledEventDelete => AuditLogActionCategory.Delete,
                     AuditLogActionType.ChannelUpdate or AuditLogActionType.EmojiUpdate or AuditLogActionType.InviteUpdate or AuditLogActionType.MemberRoleUpdate or AuditLogActionType.MemberUpdate or AuditLogActionType.OverwriteUpdate or AuditLogActionType.RoleUpdate or AuditLogActionType.WebhookUpdate or AuditLogActionType.IntegrationUpdate or AuditLogActionType.StickerUpdate or AuditLogActionType.StageInstanceUpdate or AuditLogActionType.ThreadUpdate or AuditLogActionType.GuildScheduledEventUpdate => AuditLogActionCategory.Update,
                     _ => AuditLogActionCategory.Other,
                 };
                 entry.Discord = this.Discord;
                 entry.ActionType = xac.ActionType;
                 entry.Id = xac.Id;
                 entry.Reason = xac.Reason;
                 entry.UserResponsible = amd[xac.UserId];
                 entries.Add(entry);
             }
 
             return new ReadOnlyCollection<DiscordAuditLogEntry>(entries);
         }
 
         /// <summary>
         /// Gets all of this guild's custom emojis.
         /// </summary>
         /// <returns>All of this guild's custom emojis.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordGuildEmoji>> GetEmojisAsync()
             => this.Discord.ApiClient.GetGuildEmojisAsync(this.Id);
 
         /// <summary>
         /// Gets this guild's specified custom emoji.
         /// </summary>
         /// <param name="id">ID of the emoji to get.</param>
         /// <returns>The requested custom emoji.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> GetEmojiAsync(ulong id)
             => this.Discord.ApiClient.GetGuildEmojiAsync(this.Id, id);
 
         /// <summary>
         /// Creates a new custom emoji for this guild.
         /// </summary>
         /// <param name="name">Name of the new emoji.</param>
         /// <param name="image">Image to use as the emoji.</param>
         /// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns>The newly-created emoji.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> CreateEmojiAsync(string name, Stream image, IEnumerable<DiscordRole> roles = null, string reason = null)
         {
             if (string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
 
             name = name.Trim();
             if (name.Length < 2 || name.Length > 50)
                 throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.");
 
             if (image == null)
                 throw new ArgumentNullException(nameof(image));
 
             string image64 = null;
             using (var imgtool = new ImageTool(image))
                 image64 = imgtool.GetBase64();
 
             return this.Discord.ApiClient.CreateGuildEmojiAsync(this.Id, name, image64, roles?.Select(xr => xr.Id), reason);
         }
 
         /// <summary>
         /// Modifies a this guild's custom emoji.
         /// </summary>
         /// <param name="emoji">Emoji to modify.</param>
         /// <param name="name">New name for the emoji.</param>
         /// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns>The modified emoji.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildEmoji> ModifyEmojiAsync(DiscordGuildEmoji emoji, string name, IEnumerable<DiscordRole> roles = null, string reason = null)
         {
             if (emoji == null)
                 throw new ArgumentNullException(nameof(emoji));
 
             if (emoji.Guild.Id != this.Id)
                 throw new ArgumentException("This emoji does not belong to this guild.");
 
             if (string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
 
             name = name.Trim();
             return name.Length < 2 || name.Length > 50
                 ? throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.")
                 : this.Discord.ApiClient.ModifyGuildEmojiAsync(this.Id, emoji.Id, name, roles?.Select(xr => xr.Id), reason);
         }
 
         /// <summary>
         /// Deletes this guild's custom emoji.
         /// </summary>
         /// <param name="emoji">Emoji to delete.</param>
         /// <param name="reason">Reason for audit log.</param>
         /// <returns></returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task DeleteEmojiAsync(DiscordGuildEmoji emoji, string reason = null)
         {
             return emoji == null
                 ? throw new ArgumentNullException(nameof(emoji))
                 : emoji.Guild.Id != this.Id
                 ? throw new ArgumentException("This emoji does not belong to this guild.")
                 : this.Discord.ApiClient.DeleteGuildEmojiAsync(this.Id, emoji.Id, reason);
         }
 
         /// <summary>
         /// Gets all of this guild's custom stickers.
         /// </summary>
         /// <returns>All of this guild's custom stickers.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<IReadOnlyList<DiscordSticker>> GetStickersAsync()
         {
             var stickers = await this.Discord.ApiClient.GetGuildStickersAsync(this.Id);
 
             foreach (var xstr in stickers)
             {
                 this._stickers.AddOrUpdate(xstr.Id, xstr, (id, old) =>
                 {
                     old.Name = xstr.Name;
                     old.Description = xstr.Description;
                     old._internalTags = xstr._internalTags;
                     return old;
                 });
             }
 
             return stickers;
         }
 
         /// <summary>
         /// Gets a sticker
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
         public Task<DiscordSticker> GetStickerAsync(ulong sticker_id)
             => this.Discord.ApiClient.GetGuildStickerAsync(this.Id, sticker_id);
 
         /// <summary>
         /// Creates a sticker
         /// </summary>
         /// <param name="name">The name of the sticker.</param>
         /// <param name="description">The optional description of the sticker.</param>
         /// <param name="emoji">The emoji to associate the sticker with.</param>
         /// <param name="format">The file format the sticker is written in.</param>
         /// <param name="file">The sticker.</param>
         /// <param name="reason">Audit log reason</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordSticker> CreateStickerAsync(string name, string description, DiscordEmoji emoji, Stream file, StickerFormat format, string reason = null)
         {
             var fileExt = format switch
             {
                 StickerFormat.PNG => "png",
                 StickerFormat.APNG => "png",
                 StickerFormat.LOTTIE => "json",
                 _ => throw new InvalidOperationException("This format is not supported.")
             };
 
             var contentType = format switch
             {
                 StickerFormat.PNG => "image/png",
                 StickerFormat.APNG => "image/png",
                 StickerFormat.LOTTIE => "application/json",
                 _ => throw new InvalidOperationException("This format is not supported.")
             };
 
             return emoji.Id is not 0
                 ? throw new InvalidOperationException("Only unicode emoji can be used for stickers.")
                 : name.Length < 2 || name.Length > 30
                 ? throw new ArgumentOutOfRangeException(nameof(name), "Sticker name needs to be between 2 and 30 characters long.")
                 : description.Length < 1 || description.Length > 100
                 ? throw new ArgumentOutOfRangeException(nameof(description), "Sticker description needs to be between 1 and 100 characters long.")
                 : this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new("sticker", file, null, fileExt, contentType), reason);
         }
 
         /// <summary>
         /// Modifies a sticker
         /// </summary>
         /// <param name="sticker">The id of the sticker to modify</param>
         /// <param name="name">The name of the sticker</param>
         /// <param name="description">The description of the sticker</param>
         /// <param name="emoji">The emoji to associate with this sticker.</param>
         /// <param name="reason">Audit log reason</param>
         /// <returns>A sticker object</returns>
         /// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
         public async Task<DiscordSticker> ModifyStickerAsync(ulong sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
         {
 
             string uemoji = null;
 
             if (!this._stickers.TryGetValue(sticker, out var stickerobj) || stickerobj.Guild.Id != this.Id)
                 throw new ArgumentException("This sticker does not belong to this guild.");
             if (name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30))
                 throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.");
             if (description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100))
                 throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.");
             if (emoji.HasValue && emoji.Value.Id > 0)
                 throw new ArgumentException("Only unicode emojis can be used with stickers.");
             else if (emoji.HasValue)
                 uemoji = emoji.Value.GetDiscordName().Replace(":", "");
 
             var usticker = await this.Discord.ApiClient.ModifyGuildStickerAsync(this.Id, sticker, name, description, uemoji, reason).ConfigureAwait(false);
 
 
             if (this._stickers.TryGetValue(usticker.Id, out var old))
                 this._stickers.TryUpdate(usticker.Id, usticker, old);
 
             return usticker;
         }
 
         /// <summary>
         /// Modifies a sticker
         /// </summary>
         /// <param name="sticker">The sticker to modify</param>
         /// <param name="name">The name of the sticker</param>
         /// <param name="description">The description of the sticker</param>
         /// <param name="emoji">The emoji to associate with this sticker.</param>
         /// <param name="reason">Audit log reason</param>
         /// <returns>A sticker object</returns>
         /// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
         public Task<DiscordSticker> ModifyStickerAsync(DiscordSticker sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
             => this.ModifyStickerAsync(sticker.Id, name, description, emoji, reason);
 
         /// <summary>
         /// Deletes a sticker
         /// </summary>
         /// <param name="sticker">Id of sticker to delete</param>
         /// <param name="reason">Audit log reason</param>
         /// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
         public Task DeleteStickerAsync(ulong sticker, string reason = null)
         {
             return !this._stickers.TryGetValue(sticker, out var stickerobj)
                 ? throw new ArgumentNullException(nameof(sticker))
                 : stickerobj.Guild.Id != this.Id
                 ? throw new ArgumentException("This sticker does not belong to this guild.")
                 : this.Discord.ApiClient.DeleteGuildStickerAsync(this.Id, sticker, reason);
         }
 
         /// <summary>
         /// Deletes a sticker
         /// </summary>
         /// <param name="sticker">Sticker to delete</param>
         /// <param name="reason">Audit log reason</param>
         /// <exception cref="UnauthorizedException">Thrown when the sticker could not be found.</exception>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         /// <exception cref="ArgumentException">Sticker does not belong to a guild.</exception>
         public Task DeleteStickerAsync(DiscordSticker sticker, string reason = null)
             => this.DeleteStickerAsync(sticker.Id, reason);
 
         /// <summary>
         /// <para>Gets the default channel for this guild.</para>
         /// <para>Default channel is the first channel current member can see.</para>
         /// </summary>
         /// <returns>This member's default guild.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public DiscordChannel GetDefaultChannel()
         {
             return this._channels?.Values.Where(xc => xc.Type == ChannelType.Text)
                     .OrderBy(xc => xc.Position)
                     .FirstOrDefault(xc => (xc.PermissionsFor(this.CurrentMember) & DisCatSharp.Permissions.AccessChannels) == DisCatSharp.Permissions.AccessChannels);
         }
 
         /// <summary>
         /// Gets the guild's widget
         /// </summary>
         /// <returns>The guild's widget</returns>
         public Task<DiscordWidget> GetWidgetAsync()
             => this.Discord.ApiClient.GetGuildWidgetAsync(this.Id);
 
         /// <summary>
         /// Gets the guild's widget settings
         /// </summary>
         /// <returns>The guild's widget settings</returns>
         public Task<DiscordWidgetSettings> GetWidgetSettingsAsync()
             => this.Discord.ApiClient.GetGuildWidgetSettingsAsync(this.Id);
 
         /// <summary>
         /// Modifies the guild's widget settings
         /// </summary>
         /// <param name="isEnabled">If the widget is enabled or not</param>
         /// <param name="channel">Widget channel</param>
         /// <param name="reason">Reason the widget settings were modified</param>
         /// <returns>The newly modified widget settings</returns>
         public Task<DiscordWidgetSettings> ModifyWidgetSettingsAsync(bool? isEnabled = null, DiscordChannel channel = null, string reason = null)
             => this.Discord.ApiClient.ModifyGuildWidgetSettingsAsync(this.Id, isEnabled, channel?.Id, reason);
 
         /// <summary>
         /// Gets all of this guild's templates.
         /// </summary>
         /// <returns>All of the guild's templates.</returns>
         /// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordGuildTemplate>> GetTemplatesAsync()
             => this.Discord.ApiClient.GetGuildTemplatesAsync(this.Id);
 
         /// <summary>
         /// Creates a guild template.
         /// </summary>
         /// <param name="name">Name of the template.</param>
         /// <param name="description">Description of the template.</param>
         /// <returns>The template created.</returns>
         /// <exception cref="BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
         /// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> CreateTemplateAsync(string name, string description = null)
             => this.Discord.ApiClient.CreateGuildTemplateAsync(this.Id, name, description);
 
         /// <summary>
         /// Syncs the template to the current guild's state.
         /// </summary>
         /// <param name="code">The code of the template to sync.</param>
         /// <returns>The template synced.</returns>
         /// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
         /// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> SyncTemplateAsync(string code)
             => this.Discord.ApiClient.SyncGuildTemplateAsync(this.Id, code);
 
         /// <summary>
         /// Modifies the template's metadata.
         /// </summary>
         /// <param name="code">The template's code.</param>
         /// <param name="name">Name of the template.</param>
         /// <param name="description">Description of the template.</param>
         /// <returns>The template modified.</returns>
         /// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
         /// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> ModifyTemplateAsync(string code, string name = null, string description = null)
             => this.Discord.ApiClient.ModifyGuildTemplateAsync(this.Id, code, name, description);
 
         /// <summary>
         /// Deletes the template.
         /// </summary>
         /// <param name="code">The code of the template to delete.</param>
         /// <returns>The deleted template.</returns>
         /// <exception cref="NotFoundException">Throws when the template for the code cannot be found</exception>
         /// <exception cref="UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildTemplate> DeleteTemplateAsync(string code)
             => this.Discord.ApiClient.DeleteGuildTemplateAsync(this.Id, code);
 
         /// <summary>
         /// Gets this guild's membership screening form.
         /// </summary>
         /// <returns>This guild's membership screening form.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildMembershipScreening> GetMembershipScreeningFormAsync()
             => this.Discord.ApiClient.GetGuildMembershipScreeningFormAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild's membership screening form.
         /// </summary>
         /// <param name="action">Action to perform</param>
         /// <returns>The modified screening form.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuildMembershipScreening> ModifyMembershipScreeningFormAsync(Action<MembershipScreeningEditModel> action)
         {
             var mdl = new MembershipScreeningEditModel();
             action(mdl);
             return await this.Discord.ApiClient.ModifyGuildMembershipScreeningFormAsync(this.Id, mdl.Enabled, mdl.Fields, mdl.Description);
         }
 
         /// <summary>
         /// Gets all the application commands in this guild.
         /// </summary>
         /// <returns>A list of application commands in this guild.</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> GetApplicationCommandsAsync() =>
             this.Discord.ApiClient.GetGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id);
 
         /// <summary>
         /// Overwrites the existing application commands in this guild. New commands are automatically created and missing commands are automatically delete
         /// </summary>
         /// <param name="commands">The list of commands to overwrite with.</param>
         /// <returns>The list of guild commands</returns>
         public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
             this.Discord.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id, commands);
 
         /// <summary>
         /// Creates or overwrites a application command in this guild.
         /// </summary>
         /// <param name="command">The command to create.</param>
         /// <returns>The created command.</returns>
         public Task<DiscordApplicationCommand> CreateApplicationCommandAsync(DiscordApplicationCommand command) =>
             this.Discord.ApiClient.CreateGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, command);
 
         /// <summary>
         /// Edits a application command in this guild.
         /// </summary>
         /// <param name="commandId">The id of the command to edit.</param>
         /// <param name="action">Action to perform.</param>
         /// <returns>The edit command.</returns>
         public async Task<DiscordApplicationCommand> EditApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
         {
             var mdl = new ApplicationCommandEditModel();
             action(mdl);
             return await this.Discord.ApiClient.EditGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets this guild's welcome screen.
         /// </summary>
         /// <returns>This guild's welcome screen object.</returns>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<DiscordGuildWelcomeScreen> GetWelcomeScreenAsync() =>
             this.Discord.ApiClient.GetGuildWelcomeScreenAsync(this.Id);
 
         /// <summary>
         /// Modifies this guild's welcome screen.
         /// </summary>
         /// <param name="action">Action to perform.</param>
         /// <returns>The modified welcome screen.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public async Task<DiscordGuildWelcomeScreen> ModifyWelcomeScreenAsync(Action<WelcomeScreenEditModel> action)
         {
             var mdl = new WelcomeScreenEditModel();
             action(mdl);
             return await this.Discord.ApiClient.ModifyGuildWelcomeScreenAsync(this.Id, mdl.Enabled, mdl.WelcomeChannels, mdl.Description).ConfigureAwait(false);
         }
         #endregion
 
         /// <summary>
         /// Returns a string representation of this guild.
         /// </summary>
         /// <returns>String representation of this guild.</returns>
         public override string ToString() => $"Guild {this.Id}; {this.Name}";
 
         /// <summary>
         /// Checks whether this <see cref="DiscordGuild"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordGuild"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordGuild);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordGuild"/> is equal to another <see cref="DiscordGuild"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordGuild"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordGuild"/> is equal to this <see cref="DiscordGuild"/>.</returns>
         public bool Equals(DiscordGuild e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordGuild"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordGuild"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordGuild"/> objects are equal.
         /// </summary>
         /// <param name="e1">First guild to compare.</param>
         /// <param name="e2">Second guild to compare.</param>
         /// <returns>Whether the two guilds are equal.</returns>
         public static bool operator ==(DiscordGuild e1, DiscordGuild e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordGuild"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First guild to compare.</param>
         /// <param name="e2">Second guild to compare.</param>
         /// <returns>Whether the two guilds are not equal.</returns>
         public static bool operator !=(DiscordGuild e1, DiscordGuild e2)
             => !(e1 == e2);
 
     }
 
     /// <summary>
     /// Represents guild verification level.
     /// </summary>
     public enum VerificationLevel : int
     {
         /// <summary>
         /// No verification. Anyone can join and chat right away.
         /// </summary>
         None = 0,
 
         /// <summary>
         /// Low verification level. Users are required to have a verified email attached to their account in order to be able to chat.
         /// </summary>
         Low = 1,
 
         /// <summary>
         /// Medium verification level. Users are required to have a verified email attached to their account, and account age need to be at least 5 minutes in order to be able to chat.
         /// </summary>
         Medium = 2,
 
         /// <summary>
         /// High verification level. Users are required to have a verified email attached to their account, account age need to be at least 5 minutes, and they need to be in the server for at least 10 minutes in order to be able to chat.
         /// </summary>
         High = 3,
 
         /// <summary>
         /// Highest verification level. Users are required to have a verified phone number attached to their account.
         /// </summary>
         Highest = 4
     }
 
     /// <summary>
     /// Represents default notification level for a guild.
     /// </summary>
     public enum DefaultMessageNotifications : int
     {
         /// <summary>
         /// All messages will trigger push notifications.
         /// </summary>
         AllMessages = 0,
 
         /// <summary>
         /// Only messages that mention the user (or a role he's in) will trigger push notifications.
         /// </summary>
         MentionsOnly = 1
     }
 
     /// <summary>
     /// Represents multi-factor authentication level required by a guild to use administrator functionality.
     /// </summary>
     public enum MfaLevel : int
     {
         /// <summary>
         /// Multi-factor authentication is not required to use administrator functionality.
         /// </summary>
         Disabled = 0,
 
         /// <summary>
         /// Multi-factor authentication is required to use administrator functionality.
         /// </summary>
         Enabled = 1
     }
 
     /// <summary>
     /// Represents the value of explicit content filter in a guild.
     /// </summary>
     public enum ExplicitContentFilter : int
     {
         /// <summary>
         /// Explicit content filter is disabled.
         /// </summary>
         Disabled = 0,
 
         /// <summary>
         /// Only messages from members without any roles are scanned.
         /// </summary>
         MembersWithoutRoles = 1,
 
         /// <summary>
         /// Messages from all members are scanned.
         /// </summary>
         AllMembers = 2
     }
 
     /// <summary>
     /// Represents the formats for a guild widget.
     /// </summary>
     public enum WidgetType : int
     {
         /// <summary>
         /// The widget is represented in shield format.
         /// <para>This is the default widget type.</para>
         /// </summary>
         Shield = 0,
 
         /// <summary>
         /// The widget is represented as the first banner type.
         /// </summary>
         Banner1 = 1,
 
         /// <summary>
         /// The widget is represented as the second banner type.
         /// </summary>
         Banner2 = 2,
 
         /// <summary>
         /// The widget is represented as the third banner type.
         /// </summary>
         Banner3 = 3,
 
         /// <summary>
         /// The widget is represented in the fourth banner type.
         /// </summary>
         Banner4 = 4
     }
 
     /// <summary>
     /// Represents the guild features.
     /// </summary>
     public class GuildFeatures
     {
         /// <summary>
         /// Guild has access to set an animated guild icon.
         /// </summary>
         public bool CanSetAnimatedIcon { get; }
 
         /// <summary>
         /// Guild has access to set a guild banner image.
         /// </summary>
         public bool CanSetBanner { get; }
 
         /// <summary>
         /// Guild has access to use commerce features (i.e. create store channels)
         /// </summary>
         public bool CanCreateStoreChannels { get; }
 
         /// <summary>
         /// Guild can enable Welcome Screen, Membership Screening, Stage Channels, News Channels and receives community updates.
         /// Furthermore the guild can apply as a partner and for the discovery (if the prerequisites are given).
         /// <see cref="ChannelType.Stage"/> and <see cref="ChannelType.News"/> is usable.
         /// </summary>
         public bool HasCommunityEnabled { get; }
 
         /// <summary>
         /// Guild is able to be discovered in the discovery.
         /// </summary>
         public bool IsDiscoverable { get; }
 
         /// <summary>
         /// Guild is able to be featured in the discovery.
         /// </summary>
         public bool IsFeatureable { get; }
 
         /// <summary>
         /// Guild has access to set an invite splash background.
         /// </summary>
         public bool CanSetInviteSplash { get; }
 
         /// <summary>
         /// Guild has enabled Membership Screening.
         /// </summary>
         public bool HasMembershipScreeningEnabled { get; }
 
         /// <summary>
         /// Guild has access to create news channels.
         /// <see cref="ChannelType.News"/> is usable.
         /// </summary>
         public bool CanCreateNewsChannels { get; }
 
         /// <summary>
         /// Guild is partnered.
         /// </summary>
         public bool IsPartnered { get; }
 
         /// <summary>
         /// Guild has increased custom emoji slots.
         /// </summary>
         public bool CanUploadMoreEmojis { get; }
 
         /// <summary>
         /// Guild can be previewed before joining via Membership Screening or the discovery.
         /// </summary>
         public bool HasPreviewEnabled { get; }
 
         /// <summary>
         /// Guild has access to set a vanity URL.
         /// </summary>
         public bool CanSetVanityUrl { get; }
 
         /// <summary>
         /// Guild is verified.
         /// </summary>
         public bool IsVerified { get; }
 
         /// <summary>
         /// Guild has access to set 384kbps bitrate in voice (previously VIP voice servers).
         /// </summary>
         public bool CanAccessVipRegions { get; }
 
         /// <summary>
         /// Guild has enabled the welcome screen.
         /// </summary>
         public bool HasWelcomeScreenEnabled { get; }
 
         /// <summary>
         /// Guild has enabled ticketed events.
         /// </summary>
         public bool HasTicketedEventsEnabled { get; }
 
         /// <summary>
         /// Guild has enabled monetization.
         /// </summary>
         public bool HasMonetizationEnabled { get; }
 
         /// <summary>
         /// Guild has increased custom sticker slots.
         /// </summary>
         public bool CanUploadMoreStickers { get; }
 
         /// <summary>
         /// Guild has access to the three day archive time for threads.
         /// Needs Premium Tier 1 (<see cref="PremiumTier.Tier1"/>).
         /// </summary>
         public bool CanSetThreadArchiveDurationThreeDays { get; }
 
         /// <summary>
         /// Guild has access to the seven day archive time for threads.
         /// Needs Premium Tier 2 (<see cref="PremiumTier.Tier2"/>).
         /// </summary>
         public bool CanSetThreadArchiveDurationSevenDays { get; }
 
         /// <summary>
         /// Guild has access to create private threads.
         /// Needs Premium Tier 2 (<see cref="PremiumTier.Tier2"/>).
         /// </summary>
         public bool CanCreatePrivateThreads { get; }
 
         /// <summary>
         /// Guild is a hub.
         /// <see cref="ChannelType.GuildDirectory"/> is usable.
         /// </summary>
         public bool IsHub { get; }
 
         /// <summary>
         /// Guild is in a hub.
         /// https://github.com/discord/discord-api-docs/pull/3757/commits/4932d92c9d0c783861bc715bf7ebbabb15114e34
         /// </summary>
         public bool HasDirectoryEntry { get; }
 
         /// <summary>
         /// Guild is linked to a hub.
         /// </summary>
         public bool IsLinkedToHub { get; }
 
         /// <summary>
         /// Guild has full access to threads.
         /// Old Feature.
         /// </summary>
         public bool HasThreadTestingEnabled { get; }
 
         /// <summary>
         /// Guild has access to threads.
         /// </summary>
         public bool HasThreadsEnabled { get; }
 
         /// <summary>
         /// Guild can set role icons.
         /// </summary>
         public bool CanSetRoleIcons { get; }
 
         /// <summary>
         /// Guild has the new thread permissions.
         /// Old Feature.
         /// </summary>
         public bool HasNewThreadPermissions { get; }
 
         /// <summary>
         /// Guild can set thread default auto archive duration.
         /// Old Feature.
         /// </summary>
         public bool CanSetThreadDefaultAutoArchiveDuration { get; }
 
         /// <summary>
         /// Guild has enabled role subsriptions.
         /// </summary>
         public bool HasRoleSubscriptionsEnabled { get; }
 
         /// <summary>
         /// Guild role subsriptions as purchaseable.
         /// </summary>
         public bool RoleSubscriptionsIsAvaiableForPurchase { get; }
 
         /// <summary>
         /// Guild has premium tier 3 override.
         /// </summary>
         public bool PremiumTierThreeOverride { get; }
 
         /// <summary>
         /// Guild has access to text in voice.
         /// Restricted to <see cref="IsStaffOnly"/>.
         /// </summary>
         public bool TextInVoiceEnabled { get; }
 
         /// <summary>
         /// Guild can set an animated banner.
         /// Needs Premium Tier 3 (<see cref="PremiumTier.Tier3"/>).
         /// </summary>
         public bool CanSetAnimatedBanner { get; }
 
         /// <summary>
         /// Guild can set an animated banner.
         /// Needs Premium Tier 3 (<see cref="PremiumTier.Tier3"/>).
         /// </summary>
         public bool CanSetChannelBanner { get; }
 
         /// <summary>
         /// Allows members to customize their avatar, banner and bio for that server.
         /// </summary>
         public bool HasMemberProfiles { get; }
 
         /// <summary>
         /// Guild is restricted to users with the <see cref="UserFlags.DiscordEmployee"/> badge.
         /// </summary>
         public bool IsStaffOnly { get; }
 
         /// <summary>
         /// String of guild features.
         /// </summary>
         public string FeatureString { get; }
 
         /// <summary>
         /// Checks the guild features and constructs a new <see cref="GuildFeatures"/> object.
         /// </summary>
         /// <param name="guild">Guild to check</param>
         public GuildFeatures(DiscordGuild guild)
         {
             this.CanSetAnimatedIcon = guild.RawFeatures.Contains("ANIMATED_ICON");
             this.CanSetAnimatedBanner = guild.RawFeatures.Contains("ANIMATED_BANNER");
             this.CanSetBanner = guild.RawFeatures.Contains("BANNER");
             this.CanSetChannelBanner = guild.RawFeatures.Contains("CHANNEL_BANNER");
             this.CanCreateStoreChannels = guild.RawFeatures.Contains("COMMERCE");
             this.HasCommunityEnabled = guild.RawFeatures.Contains("COMMUNITY");
             this.IsDiscoverable = !guild.RawFeatures.Contains("DISCOVERABLE_DISABLED") && guild.RawFeatures.Contains("DISCOVERABLE");
             this.IsFeatureable = guild.RawFeatures.Contains("FEATURABLE");
             this.CanSetInviteSplash = guild.RawFeatures.Contains("INVITE_SPLASH");
             this.HasMembershipScreeningEnabled = guild.RawFeatures.Contains("MEMBER_VERIFICATION_GATE_ENABLED");
             this.CanCreateNewsChannels = guild.RawFeatures.Contains("NEWS");
             this.IsPartnered = guild.RawFeatures.Contains("PARTNERED");
             this.CanUploadMoreEmojis = guild.RawFeatures.Contains("MORE_EMOJI");
             this.HasPreviewEnabled = guild.RawFeatures.Contains("PREVIEW_ENABLED");
             this.CanSetVanityUrl = guild.RawFeatures.Contains("VANITY_URL");
             this.IsVerified = guild.RawFeatures.Contains("VERIFIED");
             this.CanAccessVipRegions = guild.RawFeatures.Contains("VIP_REGIONS");
             this.HasWelcomeScreenEnabled = guild.RawFeatures.Contains("WELCOME_SCREEN_ENABLED");
             this.HasTicketedEventsEnabled = guild.RawFeatures.Contains("TICKETED_EVENTS_ENABLED");
             this.HasMonetizationEnabled = guild.RawFeatures.Contains("MONETIZATION_ENABLED");
             this.CanUploadMoreStickers = guild.RawFeatures.Contains("MORE_STICKERS");
             this.CanSetThreadArchiveDurationThreeDays = guild.RawFeatures.Contains("THREE_DAY_THREAD_ARCHIVE");
             this.CanSetThreadArchiveDurationSevenDays = guild.RawFeatures.Contains("SEVEN_DAY_THREAD_ARCHIVE");
             this.CanCreatePrivateThreads = guild.RawFeatures.Contains("PRIVATE_THREADS");
             this.IsHub = guild.RawFeatures.Contains("HUB");
             this.HasThreadTestingEnabled = guild.RawFeatures.Contains("THREADS_ENABLED_TESTING");
             this.HasThreadsEnabled = guild.RawFeatures.Contains("THREADS_ENABLED");
             this.CanSetRoleIcons = guild.RawFeatures.Contains("ROLE_ICONS");
             this.HasNewThreadPermissions = guild.RawFeatures.Contains("NEW_THREAD_PERMISSIONS");
             this.HasRoleSubscriptionsEnabled = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_ENABLED");
             this.PremiumTierThreeOverride = guild.RawFeatures.Contains("PREMIUM_TIER_3_OVERRIDE");
             this.CanSetThreadDefaultAutoArchiveDuration = guild.RawFeatures.Contains("THREAD_DEFAULT_AUTO_ARCHIVE_DURATION");
             this.TextInVoiceEnabled = guild.RawFeatures.Contains("TEXT_IN_VOICE_ENABLED");
             this.HasDirectoryEntry = guild.RawFeatures.Contains("HAS_DIRECTORY_ENTRY");
             this.IsLinkedToHub = guild.RawFeatures.Contains("LINKED_TO_HUB");
             this.HasMemberProfiles = guild.RawFeatures.Contains("MEMBER_PROFILES");
             this.IsStaffOnly = guild.RawFeatures.Contains("INTERNAL_EMPLOYEE_ONLY");
             this.RoleSubscriptionsIsAvaiableForPurchase = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE");
 
             var _features = guild.RawFeatures.Any() ? "" : "None";
             foreach (var feature in guild.RawFeatures)
             {
                 _features += feature + " ";
             }
             this.FeatureString = _features;
 
         }
     }
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index 8da01bcfe..305cff3ad 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5132 +1,5137 @@
 // 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.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, ScheduledEventPrivacyLevel privacy_level, 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,
                 PrivacyLevel = privacy_level,
                 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.OnGuildScheduledEventUpdateEventAsync(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<ScheduledEventPrivacyLevel> privacy_level, 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,
                 PrivacyLevel = privacy_level,
                 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 (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 (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>
-        internal async Task<DiscordScheduledEvent> GetGuildScheduledEventAsync(ulong guild_id, ulong scheduled_event_id)
+        /// <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 != null)
+                urlparams["with_user_count"] = with_user_count.Value.ToString(CultureInfo.InvariantCulture);
+
             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, this.Discord.Configuration);
+            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 (this.Discord is DiscordClient dc)
                 await dc.OnGuildScheduledEventUpdateEventAsync(scheduled_event, guild);
 
             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 != null)
                 urlparams["with_user_count"] = with_user_count.Value.ToString(CultureInfo.InvariantCulture);
 
             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;
                 events.Add(ev.Id, ev);
 
                 if (this.Discord is DiscordClient dc)
                     await dc.OnGuildScheduledEventUpdateEventAsync(ev, guild);
             }
 
             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.
         /// </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="with_member">Wether to include guild member data. attaches guild_member property to the user object.</param>
         internal async Task<IReadOnlyDictionary<int, DiscordScheduledEventUser>> GetGuildScheduledEventRSPVUsersAsync(ulong guild_id, ulong scheduled_event_id, int? limit, bool? with_member)
         {
             var urlparams = new Dictionary<string, string>();
             if (limit != null && limit > 0)
                 urlparams["limit"] = limit.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 = DiscordJson.ToDiscordObject<List<DiscordScheduledEventUser>>(res.Response);
             Dictionary<int, DiscordScheduledEventUser> rspv = new();
 
             foreach (var rspv_user in rspv_users)
             {
 
                 rspv_user.Discord = this.Discord;
                 rspv_user.GuildId = guild_id;
 
                 if (with_member.HasValue && with_member.Value)
                 {
                     rspv_user.Member.Discord = this.Discord;
                     rspv_user.Member = this.Discord.Guilds[guild_id]._members.AddOrUpdate(rspv_user.Member.Id, rspv_user.Member, (id, old) =>
                     {
                         old.Nickname = rspv_user.Member.Nickname;
                         old._role_ids = rspv_user.Member._role_ids;
                         old.GuildAvatarHash = rspv_user.Member.GuildAvatarHash;
                         old.GuildBannerHash = rspv_user.Member.GuildBannerHash;
                         old.GuildBio = rspv_user.Member.GuildBio;
                         return old;
                     });
                 }
 
                 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;
                 });
                 rspv.Add(rspv.GetHashCode(), rspv_user);
             }
 
             return new ReadOnlyDictionary<int, DiscordScheduledEventUser>(new Dictionary<int, 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
             {
                 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);
                 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;
                 }
 
                 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>
         /// <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)
         {
             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,
                 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>
             {
                 ["payload_json"] = DiscordJson.SerializeObject(pld)
             };
 
             var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
             var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { channel_id, message_id }, out var path);
 
             var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
             var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: files).ConfigureAwait(false);
 
             var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
             foreach (var file in files.Where(x => x.ResetPositionTo.HasValue))
             {
                 file.Stream.Position = file.ResetPositionTo.Value;
             }
 
             return ret;
         }
 
         /// <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, Optional<DateTimeOffset?> until, string reason)
         {
             var headers = Utilities.GetBaseHeaders();
             if (!string.IsNullOrWhiteSpace(reason))
                 headers[REASON_HEADER_NAME] = reason;
 
             var pld = new RestGuildMemberModifyPayload
             {
                 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
             };
 
             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)
                 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 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,
                 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 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 file in builder.Files.Where(x => x.ResetPositionTo.HasValue)) {
                 file.Stream.Position = file.ResetPositionTo.Value;
             }
 
             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)
         {
             try
             {
                 if (builder?.Embeds != null)
                     foreach (var embed in builder.Embeds)
                         if (embed.Timestamp != null)
                             embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
                 var pld = type == InteractionResponseType.AutoCompleteResult
                 ? new RestInteractionResponsePayload
                 {
                     Type = type,
                     Data = new DiscordInteractionApplicationCommandCallbackData
                     {
                         Content = null,
                         Embeds = null,
                         IsTTS = null,
                         Mentions = null,
                         Flags = null,
                         Components = null,
                         Choices = builder.Choices
                     }
                 }
                 : new RestInteractionResponsePayload
                 {
                     Type = type,
                     Data = builder != null ? new DiscordInteractionApplicationCommandCallbackData
                     {
                         Content = builder.Content,
                         Embeds = builder.Embeds,
                         IsTTS = builder.IsTTS,
                         Mentions = builder.Mentions,
                         Flags = builder.IsEphemeral ? MessageFlags.Ephemeral : 0,
                         Components = builder.Components,
                         Choices = null
                     } : 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)
                         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", "true").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));
                 }
             } catch(Exception ex)
             {
                 this.Discord.Logger.LogDebug(ex, ex.Message);
             }
         }
 
         /// <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.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)
                 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 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
     }
 }