diff --git a/DisCatSharp/Clients/Rest/BaseMethods/Channels/DiscordApiClient.BaseMethods.Channels.cs b/DisCatSharp/Clients/Rest/BaseMethods/Channels/DiscordApiClient.BaseMethods.Channels.cs
index 1150f5f05..3da8e46fb 100644
--- a/DisCatSharp/Clients/Rest/BaseMethods/Channels/DiscordApiClient.BaseMethods.Channels.cs
+++ b/DisCatSharp/Clients/Rest/BaseMethods/Channels/DiscordApiClient.BaseMethods.Channels.cs
@@ -1,166 +1,171 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net;
 
 public sealed partial class DiscordApiClient
 {
 	/// <summary>
 	/// Gets the channel async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal async Task<DiscordChannel> GetChannelAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.ExecuteRestRequest(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.PermissionOverwritesInternal)
 		{
 			xo.Discord = this.Discord;
 			xo.ChannelId = ret.Id;
 		}
 
+		if (ret.GuildId != null)
+			if (this.Discord.Guilds.Any(x => x.Key == ret.GuildId.Value))
+				this.Discord.Guilds.First(x => x.Key == ret.GuildId.Value).Value.ChannelsInternal.AddOrUpdate(ret.Id, ret, (oldChannel, newChannel) => newChannel);
+
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the channel async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteChannelAsync(ulong channelId, 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 = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.ExecuteRestRequest(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Adds the group dm recipient async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="accessToken">The access_token.</param>
 	/// <param name="nickname">The nickname.</param>
 
 	internal Task AddGroupDmRecipientAsync(ulong channelId, ulong userId, string accessToken, string nickname)
 	{
 		var pld = new RestChannelGroupDmRecipientAddPayload
 		{
 			AccessToken = accessToken,
 			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 = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.ExecuteRestRequest(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Removes the group dm recipient async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="userId">The user_id.</param>
 
 	internal Task RemoveGroupDmRecipientAsync(ulong channelId, ulong userId)
 	{
 		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 = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.ExecuteRestRequest(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Creates the group dm async.
 	/// </summary>
 	/// <param name="accessTokens">The access_tokens.</param>
 	/// <param name="nicks">The nicks.</param>
 
 	internal async Task<DiscordDmChannel> CreateGroupDmAsync(IEnumerable<string> accessTokens, IDictionary<ulong, string> nicks)
 	{
 		var pld = new RestUserGroupDmCreatePayload
 		{
 			AccessTokens = accessTokens,
 			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.ExecuteRestRequest(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="recipientId">The recipient_id.</param>
 
 	internal async Task<DiscordDmChannel> CreateDmAsync(ulong recipientId)
 	{
 		var pld = new RestUserDmCreatePayload
 		{
 			Recipient = recipientId
 		};
 
 		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.ExecuteRestRequest(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;
 	}
 }
diff --git a/DisCatSharp/Clients/Standalone/DiscordClient.cs b/DisCatSharp/Clients/Standalone/DiscordClient.cs
index 2d278e524..2e6e52a70 100644
--- a/DisCatSharp/Clients/Standalone/DiscordClient.cs
+++ b/DisCatSharp/Clients/Standalone/DiscordClient.cs
@@ -1,1303 +1,1309 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A Discord API wrapper.
 /// </summary>
 public sealed partial class DiscordClient : BaseDiscordClient
 {
 	#region Internal Fields/Properties
 
 	internal bool IsShard = false;
 	/// <summary>
 	/// Gets the message cache.
 	/// </summary>
 	internal RingBuffer<DiscordMessage> MessageCache { get; }
 
 	private List<BaseExtension> _extensions = new();
 	private StatusUpdate _status;
 
 	/// <summary>
 	/// Gets the connection lock.
 	/// </summary>
 	private readonly ManualResetEventSlim _connectionLock = new(true);
 
 	#endregion
 
 	#region Public Fields/Properties
 	/// <summary>
 	/// Gets the gateway protocol version.
 	/// </summary>
 	public int GatewayVersion { get; internal set; }
 
 	/// <summary>
 	/// Gets the gateway session information for this client.
 	/// </summary>
 	public GatewayInfo GatewayInfo { get; internal set; }
 
 	/// <summary>
 	/// Gets the gateway URL.
 	/// </summary>
 	public Uri GatewayUri { get; internal set; }
 
 	/// <summary>
 	/// Gets the total number of shards the bot is connected to.
 	/// </summary>
 	public int ShardCount => this.GatewayInfo != null
 		? this.GatewayInfo.ShardCount
 		: this.Configuration.ShardCount;
 
 	/// <summary>
 	/// Gets the currently connected shard ID.
 	/// </summary>
 	public int ShardId
 		=> this.Configuration.ShardId;
 
 	/// <summary>
 	/// Gets the intents configured for this client.
 	/// </summary>
 	public DiscordIntents Intents
 		=> this.Configuration.Intents;
 
 	/// <summary>
 	/// Gets a dictionary of guilds that this client is in. The dictionary's key is the guild ID. Note that the
 	/// guild objects in this dictionary will not be filled in if the specific guilds aren't available (the
 	/// <see cref="GuildAvailable"/> or <see cref="GuildDownloadCompleted"/> events haven't been fired yet)
 	/// </summary>
 	public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 	internal ConcurrentDictionary<ulong, DiscordGuild> GuildsInternal = new();
 
 	/// <summary>
 	/// Gets the websocket latency for this client.
 	/// </summary>
 	public int Ping
 		=> Volatile.Read(ref this._ping);
 
 	private int _ping;
 
 	/// <summary>
 	/// Gets the collection of presences held by this client.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, DiscordPresence> Presences
 		=> this._presencesLazy.Value;
 
 	internal Dictionary<ulong, DiscordPresence> PresencesInternal = new();
 	private Lazy<IReadOnlyDictionary<ulong, DiscordPresence>> _presencesLazy;
 
 	/// <summary>
 	/// Gets the collection of presences held by this client.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordActivity> EmbeddedActivities
 		=> this._embeddedActivitiesLazy.Value;
 
 	internal Dictionary<string, DiscordActivity> EmbeddedActivitiesInternal = new();
 	private Lazy<IReadOnlyDictionary<string, DiscordActivity>> _embeddedActivitiesLazy;
 	#endregion
 
 	#region Constructor/Internal Setup
 
 	/// <summary>
 	/// Initializes a new instance of <see cref="DiscordClient"/>.
 	/// </summary>
 	/// <param name="config">Specifies configuration parameters.</param>
 	public DiscordClient(DiscordConfiguration config)
 		: base(config)
 	{
 		if (this.Configuration.MessageCacheSize > 0)
 		{
 			var intents = this.Configuration.Intents;
 			this.MessageCache = intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages)
 					? new RingBuffer<DiscordMessage>(this.Configuration.MessageCacheSize)
 					: null;
 		}
 
 		this.InternalSetup();
 
 		this.Guilds = new ReadOnlyConcurrentDictionary<ulong, DiscordGuild>(this.GuildsInternal);
 	}
 
 	/// <summary>
 	/// Internal setup of the Client.
 	/// </summary>
 	internal void InternalSetup()
 	{
 		this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", EventExecutionLimit, this.Goof);
 		this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", EventExecutionLimit, this.Goof);
 		this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", EventExecutionLimit, this.EventErrorHandler);
 		this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", EventExecutionLimit, this.EventErrorHandler);
 		this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", EventExecutionLimit, this.EventErrorHandler);
 		this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 		this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 		this._guildDownloadCompletedEv = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", EventExecutionLimit, this.EventErrorHandler);
 		this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADD", EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADD", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageAcknowledged = new AsyncEvent<DiscordClient, MessageAcknowledgeEventArgs>("MESSAGE_ACKNOWLEDGED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messagesBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 		this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 		this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", EventExecutionLimit, this.EventErrorHandler);
 		this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMembersChunked = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", EventExecutionLimit, this.EventErrorHandler);
 		this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", EventExecutionLimit, this.EventErrorHandler);
 		this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", EventExecutionLimit, this.EventErrorHandler);
 		this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutAdded = new AsyncEvent<DiscordClient, GuildMemberTimeoutAddEventArgs>("GUILD_MEMBER_TIMEOUT_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutChanged = new AsyncEvent<DiscordClient, GuildMemberTimeoutUpdateEventArgs>("GUILD_MEMBER_TIMEOUT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutRemoved = new AsyncEvent<DiscordClient, GuildMemberTimeoutRemoveEventArgs>("GUILD_MEMBER_TIMEOUT_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._rateLimitHit = new AsyncEvent<DiscordClient, RateLimitExceptionEventArgs>("RATELIMIT_HIT", EventExecutionLimit, this.EventErrorHandler);
 
 		this.GuildsInternal.Clear();
 
 		this._presencesLazy = new Lazy<IReadOnlyDictionary<ulong, DiscordPresence>>(() => new ReadOnlyDictionary<ulong, DiscordPresence>(this.PresencesInternal));
 		this._embeddedActivitiesLazy = new Lazy<IReadOnlyDictionary<string, DiscordActivity>>(() => new ReadOnlyDictionary<string, DiscordActivity>(this.EmbeddedActivitiesInternal));
 	}
 
 	#endregion
 
 	#region Client Extension Methods
 
 	/// <summary>
 	/// Registers an extension with this client.
 	/// </summary>
 	/// <param name="ext">Extension to register.</param>
 	public void AddExtension(BaseExtension ext)
 	{
 		ext.Setup(this);
 		this._extensions.Add(ext);
 	}
 
 	/// <summary>
 	/// Retrieves a previously registered extension from this client.
 	/// </summary>
 	/// <typeparam name="T">The type of extension to retrieve.</typeparam>
 	/// <returns>The requested extension.</returns>
 	public T GetExtension<T>() where T : BaseExtension
 		=> this._extensions.FirstOrDefault(x => x.GetType() == typeof(T)) as T;
 
 	#endregion
 
 	#region Public Connection Methods
 
 	/// <summary>
 	/// Connects to the gateway.
 	/// </summary>
 	/// <param name="activity">The activity to set. Defaults to null.</param>
 	/// <param name="status">The optional status to set. Defaults to null.</param>
 	/// <param name="idlesince">Since when is the client performing the specified activity. Defaults to null.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when an invalid token was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task ConnectAsync(DiscordActivity activity = null, UserStatus? status = null, DateTimeOffset? idlesince = null)
 	{
 		// Check if connection lock is already set, and set it if it isn't
 		if (!this._connectionLock.Wait(0))
 			throw new InvalidOperationException("This client is already connected.");
 		this._connectionLock.Set();
 
 		var w = 7500;
 		var i = 5;
 		var s = false;
 		Exception cex = null;
 
 		if (activity == null && status == null && idlesince == null)
 			this._status = null;
 		else
 		{
 			var sinceUnix = idlesince != null ? (long?)Utilities.GetUnixTime(idlesince.Value) : null;
 			this._status = new StatusUpdate()
 			{
 				Activity = new TransportActivity(activity),
 				Status = status ?? UserStatus.Online,
 				IdleSince = sinceUnix,
 				IsAfk = idlesince != null,
 				ActivityInternal = activity
 			};
 		}
 
 		if (!this.IsShard)
 		{
 			if (this.Configuration.TokenType != TokenType.Bot)
 				this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 			this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this.BotLibrary, this.VersionString);
 		}
 
 		while (i-- > 0 || this.Configuration.ReconnectIndefinitely)
 		{
 			try
 			{
 				await this.InternalConnectAsync().ConfigureAwait(false);
 				s = true;
 				break;
 			}
 			catch (UnauthorizedException e)
 			{
 				FailConnection(this._connectionLock);
 				throw new Exception("Authentication failed. Check your token and try again.", e);
 			}
 			catch (PlatformNotSupportedException)
 			{
 				FailConnection(this._connectionLock);
 				throw;
 			}
 			catch (NotImplementedException)
 			{
 				FailConnection(this._connectionLock);
 				throw;
 			}
 			catch (Exception ex)
 			{
 				FailConnection(null);
 
 				cex = ex;
 				if (i <= 0 && !this.Configuration.ReconnectIndefinitely) break;
 
 				this.Logger.LogError(LoggerEvents.ConnectionFailure, ex, "Connection attempt failed, retrying in {0}s", w / 1000);
 				await Task.Delay(w).ConfigureAwait(false);
 
 				if (i > 0)
 					w *= 2;
 			}
 		}
 
 		if (!s && cex != null)
 		{
 			this._connectionLock.Set();
 			throw new Exception("Could not connect to Discord.", cex);
 		}
 
 		// non-closure, hence args
 		static void FailConnection(ManualResetEventSlim cl) =>
 			// unlock this (if applicable) so we can let others attempt to connect
 			cl?.Set();
 	}
 
 	/// <summary>
 	/// Reconnects to the gateway.
 	/// </summary>
 	/// <param name="startNewSession">Whether to start a new session.</param>
 	public Task ReconnectAsync(bool startNewSession = false)
 		=> this.InternalReconnectAsync(startNewSession, code: startNewSession ? 1000 : 4002);
 
 	/// <summary>
 	/// Disconnects from the gateway.
 	/// </summary>
 	public async Task DisconnectAsync()
 	{
 		this.Configuration.AutoReconnect = false;
 		if (this.WebSocketClient != null)
 			await this.WebSocketClient.DisconnectAsync().ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Public REST Methods
 
 	/// <summary>
 	/// Gets a user.
 	/// </summary>
 	/// <param name="userId">Id of the user</param>
 	/// <param name="fetch">Whether to fetch the user again. Defaults to true.</param>
 	/// <returns>The requested user.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordUser> GetUserAsync(ulong userId, bool fetch = true)
 	{
 		if (!fetch)
 		{
 			return this.TryGetCachedUserInternal(userId, out var usr) ? usr : new DiscordUser { Id = userId, Discord = this };
 		}
 		else
 		{
 			var usr = await this.ApiClient.GetUserAsync(userId).ConfigureAwait(false);
 			usr = this.UserCache.AddOrUpdate(userId, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				old.BannerHash = usr.BannerHash;
 				old.BannerColorInternal = usr.BannerColorInternal;
 				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 
 			return usr;
 		}
 	}
 
 	/// <summary>
 	/// Gets a channel.
 	/// </summary>
 	/// <param name="id">The id of the channel to get.</param>
 	/// <returns>The requested channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> GetChannelAsync(ulong id)
 		=> this.InternalGetCachedChannel(id) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets a thread.
 	/// </summary>
 	/// <param name="id">The id of the thread to get.</param>
 	/// <returns>The requested thread.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadChannel> GetThreadAsync(ulong id)
 		=> this.InternalGetCachedThread(id) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends a normal message.
 	/// </summary>
 	/// <param name="channel">The channel to send to.</param>
 	/// <param name="content">The message content to send.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, content, embeds: null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with an embed.
 	/// </summary>
 	/// <param name="channel">The channel to send to.</param>
 	/// <param name="embed">The embed to attach to the message.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordEmbed embed)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with content and an embed.
 	/// </summary>
 	/// <param name="channel">Channel to send to.</param>
 	/// <param name="content">The message content to send.</param>
 	/// <param name="embed">The embed to attach to the message.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content, DiscordEmbed embed)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with the <see cref="DisCatSharp.Entities.DiscordMessageBuilder"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="builder">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordMessageBuilder builder)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
 	/// <summary>
 	/// Sends a message with an <see cref="System.Action{DiscordMessageBuilder}"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="action">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 		return this.ApiClient.CreateMessageAsync(channel.Id, builder);
 	}
 
 	/// <summary>
 	/// Creates a guild. This requires the bot to be in less than 10 guilds total.
 	/// </summary>
 	/// <param name="name">Name of the guild.</param>
 	/// <param name="region">Voice region of the guild.</param>
 	/// <param name="icon">Stream containing the icon for the guild.</param>
 	/// <param name="verificationLevel">Verification level for the guild.</param>
 	/// <param name="defaultMessageNotifications">Default message notification settings for the guild.</param>
 	/// <param name="systemChannelFlags">System channel flags for the guild.</param>
 	/// <returns>The created guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuild> CreateGuildAsync(string name, string region = null, Optional<Stream> icon = default, VerificationLevel? verificationLevel = null,
 		DefaultMessageNotifications? defaultMessageNotifications = null, SystemChannelFlags? systemChannelFlags = null)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		return this.ApiClient.CreateGuildAsync(name, region, iconb64, verificationLevel, defaultMessageNotifications, systemChannelFlags);
 	}
 
 	/// <summary>
 	/// Creates a guild from a template. This requires the bot to be in less than 10 guilds total.
 	/// </summary>
 	/// <param name="code">The template code.</param>
 	/// <param name="name">Name of the guild.</param>
 	/// <param name="icon">Stream containing the icon for the guild.</param>
 	/// <returns>The created guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuild> CreateGuildFromTemplateAsync(string code, string name, Optional<Stream> icon = default)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		return this.ApiClient.CreateGuildFromTemplateAsync(code, name, iconb64);
 	}
 
 	/// <summary>
 	/// Executes a raw request.
 	/// </summary>
 	/// <example>
 	/// <c>
 	/// var request = await Client.ExecuteRawRequestAsync(RestRequestMethod.GET, $"{Endpoints.CHANNELS}/243184972190742178964/{Endpoints.INVITES}");
 	/// List&lt;DiscordInvite&gt; invites = DiscordJson.ToDiscordObject&lt;List&lt;DiscordInvite&gt;&gt;(request.Response);
 	/// </c>
 	/// </example>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="routeParams">The route parameters.</param>
 	/// <param name="jsonBody">The json body.</param>
 	/// <param name="additionalHeaders">The additional headers.</param>
 	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the resource does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <returns>A awaitable RestResponse</returns>
 	[Obsolete("This is no longer needed. Use DiscordClient.RestClient instead.", false)]
 	public async Task<RestResponse> ExecuteRawRequestAsync(RestRequestMethod method, string route, object routeParams, string jsonBody = null, Dictionary<string, string> additionalHeaders = null, double? ratelimitWaitOverride = null)
 	{
 		var bucket = this.ApiClient.Rest.GetBucket(method, route, routeParams, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Configuration);
 		var res = await this.ApiClient.ExecuteRestRequest(this, bucket, url, method, route, additionalHeaders, DiscordJson.SerializeObject(jsonBody), ratelimitWaitOverride);
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets a guild.
 	/// <para>Setting <paramref name="withCounts"/> to true will make a REST request.</para>
 	/// </summary>
 	/// <param name="id">The guild ID to search for.</param>
 	/// <param name="withCounts">Whether to include approximate presence and member counts in the returned guild.</param>
 	/// <returns>The requested Guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null)
 	{
 		if (this.GuildsInternal.TryGetValue(id, out var guild) && (!withCounts.HasValue || !withCounts.Value))
 			return guild;
 
 		guild = await this.ApiClient.GetGuildAsync(id, withCounts).ConfigureAwait(false);
 		var channels = await this.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
 		foreach (var channel in channels) guild.ChannelsInternal[channel.Id] = channel;
 
 		return guild;
 	}
 
 	/// <summary>
 	/// Gets a guild preview.
 	/// </summary>
 	/// <param name="id">The guild ID.</param>
 	/// <returns></returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
 		=> this.ApiClient.GetGuildPreviewAsync(id);
 
 	/// <summary>
 	/// Gets an invite.
 	/// </summary>
 	/// <param name="code">The invite code.</param>
 	/// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
 	/// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
 	/// <param name="scheduledEventId">The scheduled event id.</param>
 	/// <returns>The requested Invite.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the invite does not exists.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 		=> this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
 	/// <summary>
 	/// Gets a list of user connections.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordConnection>> GetConnectionsAsync()
 		=> this.ApiClient.GetCurrentUserConnectionsAsync();
 
 	/// <summary>
 	/// Gets a sticker.
 	/// </summary>
 	/// <returns>The requested sticker.</returns>
 	/// <param name="id">The id of the sticker.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the sticker does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordSticker> GetStickerAsync(ulong id)
 		=> this.ApiClient.GetStickerAsync(id);
 
 
 	/// <summary>
 	/// Gets all nitro sticker packs.
 	/// </summary>
 	/// <returns>List of sticker packs.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 		=> this.ApiClient.GetStickerPacksAsync();
 
 
 	/// <summary>
 	/// Gets the In-App OAuth Url.
 	/// </summary>
 	/// <param name="scopes">Defaults to <see cref="DisCatSharp.Enums.OAuthScopes.BOT_DEFAULT"/>.</param>
 	/// <param name="redir">Redirect Uri.</param>
 	/// <param name="permissions">Defaults to <see cref="Permissions.None"/>.</param>
 	/// <returns>The OAuth Url</returns>
 	public Uri GetInAppOAuth(Permissions permissions = Permissions.None, OAuthScopes scopes = OAuthScopes.BOT_DEFAULT, string redir = null)
 	{
 		permissions &= PermissionMethods.FullPerms;
 		// hey look, it's not all annoying and blue :P
 		return new Uri(new QueryUriBuilder($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.OAUTH2}{Endpoints.AUTHORIZE}")
 			.AddParameter("client_id", this.CurrentApplication.Id.ToString(CultureInfo.InvariantCulture))
 			.AddParameter("scope", OAuth.ResolveScopes(scopes))
 			.AddParameter("permissions", ((long)permissions).ToString(CultureInfo.InvariantCulture))
 			.AddParameter("state", "")
 			.AddParameter("redirect_uri", redir ?? "")
 			.ToString());
 	}
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <returns>The requested webhook.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWebhook> GetWebhookAsync(ulong id)
 		=> this.ApiClient.GetWebhookAsync(id);
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <param name="token">The target webhook token.</param>
 	/// <returns>The requested webhook.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
 		=> this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
 	/// <summary>
 	/// Updates current user's activity and status.
 	/// </summary>
 	/// <param name="activity">Activity to set.</param>
 	/// <param name="userStatus">Status of the user.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 	/// <returns></returns>
 	public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 		=> this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
 	/// <summary>
 	/// Edits current user.
 	/// </summary>
 	/// <param name="username">New username.</param>
 	/// <param name="avatar">New avatar.</param>
 	/// <returns>The modified user.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordUser> UpdateCurrentUserAsync(string username = null, Optional<Stream> avatar = default)
 	{
 		var av64 = ImageTool.Base64FromStream(avatar);
 
 		var usr = await this.ApiClient.ModifyCurrentUserAsync(username, av64).ConfigureAwait(false);
 
 		this.CurrentUser.Username = usr.Username;
 		this.CurrentUser.Discriminator = usr.Discriminator;
 		this.CurrentUser.AvatarHash = usr.AvatarHash;
 		return this.CurrentUser;
 	}
 
 	/// <summary>
 	/// Gets a guild template by the code.
 	/// </summary>
 	/// <param name="code">The code of the template.</param>
 	/// <returns>The guild template for the code.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 		=> this.ApiClient.GetTemplateAsync(code);
 
 	/// <summary>
 	/// Gets all the global application commands for this application.
 	/// </summary>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	/// <returns>A list of global application commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(bool withLocalizations = false) =>
 		this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id, withLocalizations);
 
 	/// <summary>
 	/// Overwrites the existing global application commands. New commands are automatically created and missing commands are automatically deleted.
 	/// </summary>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of global commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 		this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, commands);
 
 	/// <summary>
 	/// Creates or overwrites a global application command.
 	/// </summary>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(DiscordApplicationCommand command) =>
 		this.ApiClient.CreateGlobalApplicationCommandAsync(this.CurrentApplication.Id, command);
 
 	/// <summary>
 	/// Gets a global application command by its id.
 	/// </summary>
 	/// <param name="commandId">The id of the command to get.</param>
 	/// <returns>The command with the id.</returns>
 	public Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong commandId) =>
 		this.ApiClient.GetGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 	/// <summary>
 	/// Edits a global application command.
 	/// </summary>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edited command.</returns>
 	public async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 		return await this.ApiClient.EditGlobalApplicationCommandAsync(applicationId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a global application command.
 	/// </summary>
 	/// <param name="commandId">The id of the command to delete.</param>
 	public Task DeleteGlobalApplicationCommandAsync(ulong commandId) =>
 		this.ApiClient.DeleteGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 	/// <summary>
 	/// Gets all the application commands for a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to get application commands for.</param>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	/// <returns>A list of application commands in the guild.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId, bool withLocalizations = false) =>
 		this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, withLocalizations);
 
 	/// <summary>
 	/// Overwrites the existing application commands in a guild. New commands are automatically created and missing commands are automatically deleted.
 	/// </summary>
 	/// <param name="guildId">The id of the guild.</param>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of guild commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordApplicationCommand> commands) =>
 		this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, commands);
 
 	/// <summary>
 	/// Creates or overwrites a guild application command.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to create the application command in.</param>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong guildId, DiscordApplicationCommand command) =>
 		this.ApiClient.CreateGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, command);
 
 	/// <summary>
 	/// Gets a application command in a guild by its id.
 	/// </summary>
 	/// <param name="guildId">The id of the guild the application command is in.</param>
 	/// <param name="commandId">The id of the command to get.</param>
 	/// <returns>The command with the id.</returns>
 	public Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 		 this.ApiClient.GetGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	/// <summary>
 	/// Edits a application command in a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild the application command is in.</param>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edited command.</returns>
 	public async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong guildId, ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 		return await this.ApiClient.EditGuildApplicationCommandAsync(applicationId, guildId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a application command in a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to delete the application command in.</param>
 	/// <param name="commandId">The id of the command.</param>
 	public Task DeleteGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 		this.ApiClient.DeleteGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	/// <summary>
 	/// Gets all command permissions for a guild.
 	/// </summary>
 	/// <param name="guildId">The target guild.</param>
 	public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong guildId) =>
 		this.ApiClient.GetGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId);
 
 	/// <summary>
 	/// Gets the permissions for a guild command.
 	/// </summary>
 	/// <param name="guildId">The target guild.</param>
 	/// <param name="commandId">The target command id.</param>
 	public Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong guildId, ulong commandId) =>
 		this.ApiClient.GetGuildApplicationCommandPermissionAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	#endregion
 
 	#region Internal Caching Methods
 	/// <summary>
 	/// Gets the internal cached threads.
 	/// </summary>
 	/// <param name="threadId">The target thread id.</param>
 	/// <returns>The requested thread.</returns>
 	internal DiscordThreadChannel InternalGetCachedThread(ulong threadId)
 	{
 		foreach (var guild in this.Guilds.Values)
 			if (guild.Threads.TryGetValue(threadId, out var foundThread))
 				return foundThread;
 
 		return null;
 	}
 
 
 	/// <summary>
 	/// Gets the internal cached scheduled event.
 	/// </summary>
 	/// <param name="scheduledEventId">The target scheduled event id.</param>
 	/// <returns>The requested scheduled event.</returns>
 	internal DiscordScheduledEvent InternalGetCachedScheduledEvent(ulong scheduledEventId)
 	{
 		foreach (var guild in this.Guilds.Values)
 			if (guild.ScheduledEvents.TryGetValue(scheduledEventId, out var foundScheduledEvent))
 				return foundScheduledEvent;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Gets the internal cached channel.
 	/// </summary>
 	/// <param name="channelId">The target channel id.</param>
+	/// <param name="guildId">The target guild id to search for channel in.</param>
 	/// <returns>The requested channel.</returns>
-	internal DiscordChannel InternalGetCachedChannel(ulong channelId)
+	internal DiscordChannel InternalGetCachedChannel(ulong channelId, ulong? guildId = null)
 	{
-		foreach (var guild in this.Guilds.Values)
-			if (guild.Channels.TryGetValue(channelId, out var foundChannel))
-				return foundChannel;
+		if (guildId != null && guildId.HasValue)
+			if (this.Guilds.Any(x => x.Key == guildId.Value))
+				if (this.Guilds.First(x => x.Key == guildId.Value).Value.Channels.TryGetValue(channelId, out var foundChannel))
+					return foundChannel;
+		else
+			foreach (var guild in this.Guilds.Values)
+				if (guild.Channels.TryGetValue(channelId, out var foundGuildChannel))
+					return foundGuildChannel;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Gets the internal cached guild.
 	/// </summary>
 	/// <param name="guildId">The target guild id.</param>
 	/// <returns>The requested guild.</returns>
 	internal DiscordGuild InternalGetCachedGuild(ulong? guildId)
 	{
 		if (this.GuildsInternal != null && guildId.HasValue)
 		{
 			if (this.GuildsInternal.TryGetValue(guildId.Value, out var guild))
 				return guild;
 		}
 
 		return null;
 	}
 
 	/// <summary>
 	/// Updates a message.
 	/// </summary>
 	/// <param name="message">The message to update.</param>
 	/// <param name="author">The author to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <param name="member">The member to update.</param>
 	private void UpdateMessage(DiscordMessage message, TransportUser author, DiscordGuild guild, TransportMember member)
 	{
 		if (author != null)
 		{
 			var usr = new DiscordUser(author) { Discord = this };
 
 			if (member != null)
 				member.User = author;
 
 			message.Author = this.UpdateUser(usr, guild?.Id, guild, member);
 		}
 
 		var channel = this.InternalGetCachedChannel(message.ChannelId);
 
 		if (channel != null) return;
 
 		channel = !message.GuildId.HasValue
 			? new DiscordDmChannel
 			{
 				Id = message.ChannelId,
 				Discord = this,
 				Type = ChannelType.Private
 			}
 			: new DiscordChannel
 			{
 				Id = message.ChannelId,
 				Discord = this
 			};
 
 		message.Channel = channel;
 	}
 
 	/// <summary>
 	/// Updates a scheduled event.
 	/// </summary>
 	/// <param name="scheduledEvent">The scheduled event to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <returns>The updated scheduled event.</returns>
 	private DiscordScheduledEvent UpdateScheduledEvent(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		if (scheduledEvent != null)
 		{
 			_ = guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (id, old) =>
 			{
 				old.Discord = this;
 				old.Description = scheduledEvent.Description;
 				old.ChannelId = scheduledEvent.ChannelId;
 				old.EntityId = scheduledEvent.EntityId;
 				old.EntityType = scheduledEvent.EntityType;
 				old.EntityMetadata = scheduledEvent.EntityMetadata;
 				old.PrivacyLevel = scheduledEvent.PrivacyLevel;
 				old.Name = scheduledEvent.Name;
 				old.Status = scheduledEvent.Status;
 				old.UserCount = scheduledEvent.UserCount;
 				old.ScheduledStartTimeRaw = scheduledEvent.ScheduledStartTimeRaw;
 				old.ScheduledEndTimeRaw = scheduledEvent.ScheduledEndTimeRaw;
 				return old;
 			});
 		}
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Updates a user.
 	/// </summary>
 	/// <param name="usr">The user to update.</param>
 	/// <param name="guildId">The guild id to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <param name="mbr">The member to update.</param>
 	/// <returns>The updated user.</returns>
 	private DiscordUser UpdateUser(DiscordUser usr, ulong? guildId, DiscordGuild guild, TransportMember mbr)
 	{
 		if (mbr != null)
 		{
 			if (mbr.User != null)
 			{
 				usr = new DiscordUser(mbr.User) { Discord = this };
 
 				_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					old.BannerHash = usr.BannerHash;
 					old.BannerColorInternal = usr.BannerColorInternal;
 					old.Pronouns = usr.Pronouns;
 					return old;
 				});
 
 				usr = new DiscordMember(mbr) { Discord = this, GuildId = guildId.Value };
 			}
 
 			var intents = this.Configuration.Intents;
 
 			DiscordMember member = default;
 
 			if (!intents.HasAllPrivilegedIntents() || guild.IsLarge) // we have the necessary privileged intents, no need to worry about caching here unless guild is large.
 			{
 				if (guild?.MembersInternal.TryGetValue(usr.Id, out member) == false)
 				{
 					if (intents.HasIntent(DiscordIntents.GuildMembers) || this.Configuration.AlwaysCacheMembers) // member can be updated by events, so cache it
 					{
 						guild.MembersInternal.TryAdd(usr.Id, (DiscordMember)usr);
 					}
 				}
 				else if (intents.HasIntent(DiscordIntents.GuildPresences) || this.Configuration.AlwaysCacheMembers) // we can attempt to update it if it's already in cache.
 				{
 					if (!intents.HasIntent(DiscordIntents.GuildMembers)) // no need to update if we already have the member events
 					{
 						_ = guild.MembersInternal.TryUpdate(usr.Id, (DiscordMember)usr, member);
 					}
 				}
 			}
 		}
 		else if (usr.Username != null) // check if not a skeleton user
 		{
 			_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				old.BannerHash = usr.BannerHash;
 				old.BannerColorInternal = usr.BannerColorInternal;
 				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 		}
 
 		return usr;
 	}
 
 	/// <summary>
 	/// Updates the cached scheduled events in a guild.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawEvents">The raw events.</param>
 	private void UpdateCachedScheduledEvent(DiscordGuild guild, JArray rawEvents)
 	{
 		if (this._disposed)
 			return;
 
 		if (rawEvents != null)
 		{
 			guild.ScheduledEventsInternal.Clear();
 
 			foreach (var xj in rawEvents)
 			{
 				var xtm = xj.ToDiscordObject<DiscordScheduledEvent>();
 
 				xtm.Discord = this;
 
 				guild.ScheduledEventsInternal[xtm.Id] = xtm;
 			}
 		}
 	}
 
 	/// <summary>
 	/// Updates the cached guild.
 	/// </summary>
 	/// <param name="newGuild">The new guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	private void UpdateCachedGuild(DiscordGuild newGuild, JArray rawMembers)
 	{
 		if (this._disposed)
 			return;
 
 		if (!this.GuildsInternal.ContainsKey(newGuild.Id))
 			this.GuildsInternal[newGuild.Id] = newGuild;
 
 		var guild = this.GuildsInternal[newGuild.Id];
 
 		if (newGuild.ChannelsInternal != null && !newGuild.ChannelsInternal.IsEmpty)
 		{
 			foreach (var channel in newGuild.ChannelsInternal.Values)
 			{
 				if (guild.ChannelsInternal.TryGetValue(channel.Id, out _)) continue;
 
 				foreach (var overwrite in channel.PermissionOverwritesInternal)
 				{
 					overwrite.Discord = this;
 					overwrite.ChannelId = channel.Id;
 				}
 
 				guild.ChannelsInternal[channel.Id] = channel;
 			}
 		}
 
 		if (newGuild.ThreadsInternal != null && !newGuild.ThreadsInternal.IsEmpty)
 		{
 			foreach (var thread in newGuild.ThreadsInternal.Values)
 			{
 				if (guild.ThreadsInternal.TryGetValue(thread.Id, out _)) continue;
 
 				guild.ThreadsInternal[thread.Id] = thread;
 			}
 		}
 
 		if (newGuild.ScheduledEventsInternal != null && !newGuild.ScheduledEventsInternal.IsEmpty)
 		{
 			foreach (var @event in newGuild.ScheduledEventsInternal.Values)
 			{
 				if (guild.ScheduledEventsInternal.TryGetValue(@event.Id, out _)) continue;
 
 				guild.ScheduledEventsInternal[@event.Id] = @event;
 			}
 		}
 
 		foreach (var newEmoji in newGuild.EmojisInternal.Values)
 			_ = guild.EmojisInternal.GetOrAdd(newEmoji.Id, _ => newEmoji);
 
 		foreach (var newSticker in newGuild.StickersInternal.Values)
 			_ = guild.StickersInternal.GetOrAdd(newSticker.Id, _ => newSticker);
 
 		foreach (var newStageInstance in newGuild.StageInstancesInternal.Values)
 			_ = guild.StageInstancesInternal.GetOrAdd(newStageInstance.Id, _ => newStageInstance);
 
 		if (rawMembers != null)
 		{
 			guild.MembersInternal.Clear();
 
 			foreach (var xj in rawMembers)
 			{
 				var xtm = xj.ToDiscordObject<TransportMember>();
 
 				var xu = new DiscordUser(xtm.User) { Discord = this };
 				_ = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 				{
 					old.Username = xu.Username;
 					old.Discriminator = xu.Discriminator;
 					old.AvatarHash = xu.AvatarHash;
 					old.PremiumType = xu.PremiumType;
 					return old;
 				});
 
 				guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 			}
 		}
 
 		foreach (var role in newGuild.RolesInternal.Values)
 		{
 			if (guild.RolesInternal.TryGetValue(role.Id, out _)) continue;
 
 			role.GuildId = guild.Id;
 			guild.RolesInternal[role.Id] = role;
 		}
 
 		guild.Name = newGuild.Name;
 		guild.AfkChannelId = newGuild.AfkChannelId;
 		guild.AfkTimeout = newGuild.AfkTimeout;
 		guild.DefaultMessageNotifications = newGuild.DefaultMessageNotifications;
 		guild.RawFeatures = newGuild.RawFeatures;
 		guild.IconHash = newGuild.IconHash;
 		guild.MfaLevel = newGuild.MfaLevel;
 		guild.OwnerId = newGuild.OwnerId;
 		guild.VoiceRegionId = newGuild.VoiceRegionId;
 		guild.SplashHash = newGuild.SplashHash;
 		guild.VerificationLevel = newGuild.VerificationLevel;
 		guild.WidgetEnabled = newGuild.WidgetEnabled;
 		guild.WidgetChannelId = newGuild.WidgetChannelId;
 		guild.ExplicitContentFilter = newGuild.ExplicitContentFilter;
 		guild.PremiumTier = newGuild.PremiumTier;
 		guild.PremiumSubscriptionCount = newGuild.PremiumSubscriptionCount;
 		guild.PremiumProgressBarEnabled = newGuild.PremiumProgressBarEnabled;
 		guild.BannerHash = newGuild.BannerHash;
 		guild.Description = newGuild.Description;
 		guild.VanityUrlCode = newGuild.VanityUrlCode;
 		guild.SystemChannelId = newGuild.SystemChannelId;
 		guild.SystemChannelFlags = newGuild.SystemChannelFlags;
 		guild.DiscoverySplashHash = newGuild.DiscoverySplashHash;
 		guild.MaxMembers = newGuild.MaxMembers;
 		guild.MaxPresences = newGuild.MaxPresences;
 		guild.ApproximateMemberCount = newGuild.ApproximateMemberCount;
 		guild.ApproximatePresenceCount = newGuild.ApproximatePresenceCount;
 		guild.MaxVideoChannelUsers = newGuild.MaxVideoChannelUsers;
 		guild.PreferredLocale = newGuild.PreferredLocale;
 		guild.RulesChannelId = newGuild.RulesChannelId;
 		guild.PublicUpdatesChannelId = newGuild.PublicUpdatesChannelId;
 		guild.ApplicationId = newGuild.ApplicationId;
 
 		// fields not sent for update:
 		// - guild.Channels
 		// - voice states
 		// - guild.JoinedAt = new_guild.JoinedAt;
 		// - guild.Large = new_guild.Large;
 		// - guild.MemberCount = Math.Max(new_guild.MemberCount, guild._members.Count);
 		// - guild.Unavailable = new_guild.Unavailable;
 	}
 
 	/// <summary>
 	/// Populates the message reactions and cache.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The author.</param>
 	/// <param name="member">The member.</param>
 	private void PopulateMessageReactionsAndCache(DiscordMessage message, TransportUser author, TransportMember member)
 	{
 		var guild = message.Channel?.Guild ?? this.InternalGetCachedGuild(message.GuildId);
 
 		this.UpdateMessage(message, author, guild, member);
 
 		if (message.ReactionsInternal == null)
 			message.ReactionsInternal = new List<DiscordReaction>();
 		foreach (var xr in message.ReactionsInternal)
 			xr.Emoji.Discord = this;
 
 		if (this.Configuration.MessageCacheSize > 0 && message.Channel != null)
 			this.MessageCache?.Add(message);
 	}
 
 
 	#endregion
 
 	#region Disposal
 
 	~DiscordClient()
 	{
 		this.Dispose();
 	}
 
 	/// <summary>
 	/// Whether the client is disposed.
 	/// </summary>
 
 	private bool _disposed;
 
 	/// <summary>
 	/// Disposes the client.
 	/// </summary>
 	public override void Dispose()
 	{
 		if (this._disposed)
 			return;
 
 		this._disposed = true;
 		GC.SuppressFinalize(this);
 
 		this.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 		this.ApiClient.Rest.Dispose();
 		this.CurrentUser = null;
 
 		var extensions = this._extensions; // prevent _extensions being modified during dispose
 		this._extensions = null;
 		foreach (var extension in extensions)
 			if (extension is IDisposable disposable)
 				disposable.Dispose();
 
 		try
 		{
 			this._cancelTokenSource?.Cancel();
 			this._cancelTokenSource?.Dispose();
 		}
 		catch { }
 
 		this.GuildsInternal = null;
 		this._heartbeatTask = null;
 	}
 
 	#endregion
 }
diff --git a/DisCatSharp/Clients/Standalone/Dispatch/DiscordClient.Dispatch.cs b/DisCatSharp/Clients/Standalone/Dispatch/DiscordClient.Dispatch.cs
index cfeb9fabd..89170e045 100644
--- a/DisCatSharp/Clients/Standalone/Dispatch/DiscordClient.Dispatch.cs
+++ b/DisCatSharp/Clients/Standalone/Dispatch/DiscordClient.Dispatch.cs
@@ -1,3422 +1,3578 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics.Metrics;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents a discord client.
 /// </summary>
 public sealed partial class DiscordClient
 {
 	#region Private Fields
 
 	private string _sessionId;
 	private bool _guildDownloadCompleted;
 
 	private readonly Dictionary<string, KeyValuePair<TimeoutHandler, Timer>> _tempTimers = new();
 
 	/// <summary>
 	/// Represents a timeout handler.
 	/// </summary>
 	internal class TimeoutHandler
 	{
 		/// <summary>
 		/// Gets the member.
 		/// </summary>
 		internal readonly DiscordMember Member;
 
 		/// <summary>
 		/// Gets the guild.
 		/// </summary>
 		internal readonly DiscordGuild Guild;
 
 		/// <summary>
 		/// Gets the old timeout value.
 		/// </summary>
 		internal DateTime? TimeoutUntilOld;
 
 		/// <summary>
 		/// Gets the new timeout value.
 		/// </summary>
 		internal DateTime? TimeoutUntilNew;
 
 		/// <summary>
 		/// Constructs a new <see cref="TimeoutHandler"/>.
 		/// </summary>
 		/// <param name="mbr">The affected member.</param>
 		/// <param name="guild">The affected guild.</param>
 		/// <param name="too">The old timeout value.</param>
 		/// <param name="ton">The new timeout value.</param>
 		internal TimeoutHandler(DiscordMember mbr, DiscordGuild guild, DateTime? too, DateTime? ton)
 		{
 			this.Guild = guild;
 			this.Member = mbr;
 			this.TimeoutUntilOld = too;
 			this.TimeoutUntilNew = ton;
 		}
 	}
 
 	#endregion
 
 	#region Dispatch Handler
 
 	/// <summary>
 	/// Handles the dispatch payloads.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 
 	internal async Task HandleDispatchAsync(GatewayPayload payload)
 	{
 		if (payload.Data is not JObject dat)
 		{
 			this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Invalid payload body (this message is probably safe to ignore); opcode: {0} event: {1}; payload: {2}", payload.OpCode, payload.EventName, payload.Data);
 			return;
 		}
 
 		await this._payloadReceived.InvokeAsync(this, new PayloadReceivedEventArgs(this.ServiceProvider)
 		{
 			EventName = payload.EventName,
 			PayloadObject = dat
 		}).ConfigureAwait(false);
 
 		#region Default objects
 		DiscordChannel chn;
 		ulong gid;
 		ulong cid;
 		ulong uid;
 		DiscordStageInstance stg = default;
 		DiscordIntegration itg = default;
 		DiscordThreadChannel trd = default;
 		DiscordThreadChannelMember trdm = default;
 		DiscordScheduledEvent gse = default;
 		TransportUser usr = default;
 		TransportMember mbr = default;
 		TransportUser refUsr = default;
 		TransportMember refMbr = default;
 		JToken rawMbr = default;
 		var rawRefMsg = dat["referenced_message"];
 		#endregion
 
 		switch (payload.EventName.ToLowerInvariant())
 		{
 			#region Gateway Status
 
 			case "ready":
 				var glds = (JArray)dat["guilds"];
 				await this.OnReadyEventAsync(dat.ToObject<ReadyPayload>(), glds).ConfigureAwait(false);
 				break;
 
 			case "resumed":
 				await this.OnResumedAsync().ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Channel
 
 			case "channel_create":
 				chn = dat.ToObject<DiscordChannel>();
 				await this.OnChannelCreateEventAsync(chn).ConfigureAwait(false);
 				break;
 
 			case "channel_update":
 				await this.OnChannelUpdateEventAsync(dat.ToObject<DiscordChannel>()).ConfigureAwait(false);
 				break;
 
 			case "channel_delete":
 				chn = dat.ToObject<DiscordChannel>();
 				await this.OnChannelDeleteEventAsync(chn.IsPrivate ? dat.ToObject<DiscordDmChannel>() : chn).ConfigureAwait(false);
 				break;
 
 			case "channel_pins_update":
 				cid = (ulong)dat["channel_id"];
 				var ts = (string)dat["last_pin_timestamp"];
 				await this.OnChannelPinsUpdateAsync((ulong?)dat["guild_id"], cid, ts != null ? DateTimeOffset.Parse(ts, CultureInfo.InvariantCulture) : default(DateTimeOffset?)).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild
 
 			case "guild_create":
 				await this.OnGuildCreateEventAsync(dat.ToDiscordObject<DiscordGuild>(), (JArray)dat["members"], dat["presences"].ToDiscordObject<IEnumerable<DiscordPresence>>()).ConfigureAwait(false);
 				break;
 
 			case "guild_update":
 				await this.OnGuildUpdateEventAsync(dat.ToDiscordObject<DiscordGuild>(), (JArray)dat["members"]).ConfigureAwait(false);
 				break;
 
 			case "guild_delete":
 				await this.OnGuildDeleteEventAsync(dat.ToDiscordObject<DiscordGuild>()).ConfigureAwait(false);
 				break;
 
 			case "guild_sync":
 				gid = (ulong)dat["id"];
 				await this.OnGuildSyncEventAsync(this.GuildsInternal[gid], (bool)dat["large"], (JArray)dat["members"], dat["presences"].ToDiscordObject<IEnumerable<DiscordPresence>>()).ConfigureAwait(false);
 				break;
 
 			case "guild_emojis_update":
 				gid = (ulong)dat["guild_id"];
 				var ems = dat["emojis"].ToObject<IEnumerable<DiscordEmoji>>();
 				await this.OnGuildEmojisUpdateEventAsync(this.GuildsInternal[gid], ems).ConfigureAwait(false);
 				break;
 
 			case "guild_stickers_update":
 				gid = (ulong)dat["guild_id"];
 				var strs = dat["stickers"].ToDiscordObject<IEnumerable<DiscordSticker>>();
 				await this.OnStickersUpdatedAsync(strs, gid).ConfigureAwait(false);
 				break;
 
 			case "guild_integrations_update":
 				gid = (ulong)dat["guild_id"];
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationsUpdateEventAsync(this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_join_request_create":
 				break;
 
 			case "guild_join_request_update":
 				break;
 
 			case "guild_join_request_delete":
 				break;
 
 			#endregion
 
 			#region Guild Ban
 
 			case "guild_ban_add":
 				usr = dat["user"].ToObject<TransportUser>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildBanAddEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_ban_remove":
 				usr = dat["user"].ToObject<TransportUser>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildBanRemoveEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild Event
 
 			case "guild_scheduled_event_create":
 				gse = dat.ToObject<DiscordScheduledEvent>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildScheduledEventCreateEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_update":
 				gse = dat.ToObject<DiscordScheduledEvent>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildScheduledEventUpdateEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_delete":
 				gse = dat.ToObject<DiscordScheduledEvent>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildScheduledEventDeleteEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_user_add":
 				gid = (ulong)dat["guild_id"];
 				uid = (ulong)dat["user_id"];
 				await this.OnGuildScheduledEventUserAddedEventAsync((ulong)dat["guild_scheduled_event_id"], uid, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_user_remove":
 				gid = (ulong)dat["guild_id"];
 				uid = (ulong)dat["user_id"];
 				await this.OnGuildScheduledEventUserRemovedEventAsync((ulong)dat["guild_scheduled_event_id"], uid, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild Integration
 
 			case "integration_create":
 				gid = (ulong)dat["guild_id"];
 				itg = dat.ToObject<DiscordIntegration>();
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationCreateEventAsync(this.GuildsInternal[gid], itg).ConfigureAwait(false);
 				break;
 
 			case "integration_update":
 				gid = (ulong)dat["guild_id"];
 				itg = dat.ToObject<DiscordIntegration>();
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationUpdateEventAsync(this.GuildsInternal[gid], itg).ConfigureAwait(false);
 				break;
 
 			case "integration_delete":
 				gid = (ulong)dat["guild_id"];
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationDeleteEventAsync(this.GuildsInternal[gid], (ulong)dat["id"], (ulong?)dat["application_id"]).ConfigureAwait(false);
 				break;
 			#endregion
 
 			#region Guild Member
 
 			case "guild_member_add":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildMemberAddEventAsync(dat.ToObject<TransportMember>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_member_remove":
 				gid = (ulong)dat["guild_id"];
 				usr = dat["user"].ToObject<TransportUser>();
 
 				if (!this.GuildsInternal.ContainsKey(gid))
 				{
 					// discord fires this event inconsistently if the current user leaves a guild.
 					if (usr.Id != this.CurrentUser.Id)
 						this.Logger.LogError(LoggerEvents.WebSocketReceive, "Could not find {0} in guild cache", gid);
 					return;
 				}
 
 				await this.OnGuildMemberRemoveEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_member_update":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildMemberUpdateEventAsync(dat.ToDiscordObject<TransportMember>(), this.GuildsInternal[gid], dat["roles"].ToObject<IEnumerable<ulong>>(), (string)dat["nick"], (bool?)dat["pending"]).ConfigureAwait(false);
 				break;
 
 			case "guild_members_chunk":
 				await this.OnGuildMembersChunkEventAsync(dat).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild Role
 
 			case "guild_role_create":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildRoleCreateEventAsync(dat["role"].ToObject<DiscordRole>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_role_update":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildRoleUpdateEventAsync(dat["role"].ToObject<DiscordRole>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_role_delete":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildRoleDeleteEventAsync((ulong)dat["role_id"], this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Invite
 
 			case "invite_create":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnInviteCreateEventAsync(cid, gid, dat.ToObject<DiscordInvite>()).ConfigureAwait(false);
 				break;
 
 			case "invite_delete":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnInviteDeleteEventAsync(cid, gid, dat).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Message
 
 			case "message_ack":
 				cid = (ulong)dat["channel_id"];
 				var mid = (ulong)dat["message_id"];
 				await this.OnMessageAckEventAsync(this.InternalGetCachedChannel(cid), mid).ConfigureAwait(false);
 				break;
 
 			case "message_create":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				if (rawRefMsg != null && rawRefMsg.HasValues)
 				{
 					if (rawRefMsg.SelectToken("author") != null)
 					{
 						refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
 					}
 
 					if (rawRefMsg.SelectToken("member") != null)
 					{
 						refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
 					}
 				}
 
 				await this.OnMessageCreateEventAsync(dat.ToDiscordObject<DiscordMessage>(), dat["author"].ToObject<TransportUser>(), mbr, refUsr, refMbr).ConfigureAwait(false);
 				break;
 
 			case "message_update":
-				rawMbr = dat["member"];
-
-				if (rawMbr != null)
-					mbr = rawMbr.ToObject<TransportMember>();
-
-				if (rawRefMsg != null && rawRefMsg.HasValues)
-				{
-					if (rawRefMsg.SelectToken("author") != null)
-					{
-						refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
-					}
-
-					if (rawRefMsg.SelectToken("member") != null)
-					{
-						refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
-					}
-				}
-
-				await this.OnMessageUpdateEventAsync(dat.ToDiscordObject<DiscordMessage>(), dat["author"]?.ToObject<TransportUser>(), mbr, refUsr, refMbr).ConfigureAwait(false);
+				await this.OnMessageUpdateRaw(dat).ConfigureAwait(false);
 				break;
 
 			// delete event does *not* include message object
 			case "message_delete":
 				await this.OnMessageDeleteEventAsync((ulong)dat["id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "message_delete_bulk":
 				await this.OnMessageBulkDeleteEventAsync(dat["ids"].ToObject<ulong[]>(), (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Message Reaction
 
 			case "message_reaction_add":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				await this.OnMessageReactionAddAsync((ulong)dat["user_id"], (ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"], mbr, dat["emoji"].ToObject<DiscordEmoji>()).ConfigureAwait(false);
 				break;
 
 			case "message_reaction_remove":
 				await this.OnMessageReactionRemoveAsync((ulong)dat["user_id"], (ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"], dat["emoji"].ToObject<DiscordEmoji>()).ConfigureAwait(false);
 				break;
 
 			case "message_reaction_remove_all":
 				await this.OnMessageReactionRemoveAllAsync((ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "message_reaction_remove_emoji":
 				await this.OnMessageReactionRemoveEmojiAsync((ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong)dat["guild_id"], dat["emoji"]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Stage Instance
 
 			case "stage_instance_create":
 				stg = dat.ToObject<DiscordStageInstance>();
 				await this.OnStageInstanceCreateEventAsync(stg).ConfigureAwait(false);
 				break;
 
 			case "stage_instance_update":
 				stg = dat.ToObject<DiscordStageInstance>();
 				await this.OnStageInstanceUpdateEventAsync(stg).ConfigureAwait(false);
 				break;
 
 			case "stage_instance_delete":
 				stg = dat.ToObject<DiscordStageInstance>();
 				await this.OnStageInstanceDeleteEventAsync(stg).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Thread
 
 			case "thread_create":
 				trd = dat.ToObject<DiscordThreadChannel>();
 				await this.OnThreadCreateEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_update":
 				trd = dat.ToObject<DiscordThreadChannel>();
 				await this.OnThreadUpdateEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_delete":
 				trd = dat.ToObject<DiscordThreadChannel>();
 				await this.OnThreadDeleteEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_list_sync":
 				gid = (ulong)dat["guild_id"]; //get guild
 				await this.OnThreadListSyncEventAsync(this.GuildsInternal[gid], dat["channel_ids"].ToObject<IReadOnlyList<ulong?>>(), dat["threads"].ToObject<IReadOnlyList<DiscordThreadChannel>>(), dat["members"].ToObject<IReadOnlyList<DiscordThreadChannelMember>>()).ConfigureAwait(false);
 				break;
 
 			case "thread_member_update":
 				trdm = dat.ToObject<DiscordThreadChannelMember>();
 				await this.OnThreadMemberUpdateEventAsync(trdm).ConfigureAwait(false);
 				break;
 
 			case "thread_members_update":
 				gid = (ulong)dat["guild_id"];
 
 				await this.OnThreadMembersUpdateEventAsync(this.GuildsInternal[gid], (ulong)dat["id"], (JArray)dat["added_members"], (JArray)dat["removed_member_ids"], (int)dat["member_count"]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Activities
 			case "embedded_activity_update":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnEmbeddedActivityUpdateAsync((JObject)dat["embedded_activity"], this.GuildsInternal[gid], cid, (JArray)dat["users"], (ulong)dat["embedded_activity"]["application_id"]).ConfigureAwait(false);
 				break;
 			#endregion
 
 			#region User/Presence Update
 
 			case "presence_update":
 				await this.OnPresenceUpdateEventAsync(dat, (JObject)dat["user"]).ConfigureAwait(false);
 				break;
 
 			case "user_settings_update":
 				await this.OnUserSettingsUpdateEventAsync(dat.ToObject<TransportUser>()).ConfigureAwait(false);
 				break;
 
 			case "user_update":
 				await this.OnUserUpdateEventAsync(dat.ToObject<TransportUser>()).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Voice
 
 			case "voice_state_update":
 				await this.OnVoiceStateUpdateEventAsync(dat).ConfigureAwait(false);
 				break;
 
 			case "voice_server_update":
 				gid = (ulong)dat["guild_id"];
 				await this.OnVoiceServerUpdateEventAsync((string)dat["endpoint"], (string)dat["token"], this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Interaction/Integration/Application
 
 			case "interaction_create":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 				{
 					mbr = dat["member"].ToObject<TransportMember>();
 					usr = mbr.User;
 				}
 				else
 				{
 					usr = dat["user"].ToObject<TransportUser>();
 				}
 
 				cid = (ulong)dat["channel_id"];
 				// Console.WriteLine(dat.ToString()); // Get raw interaction payload.
 				await this.OnInteractionCreateAsync((ulong?)dat["guild_id"], cid, usr, mbr, dat.ToDiscordObject<DiscordInteraction>()).ConfigureAwait(false);
 				break;
 
 			case "application_command_create":
 				await this.OnApplicationCommandCreateAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "application_command_update":
 				await this.OnApplicationCommandUpdateAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "application_command_delete":
 				await this.OnApplicationCommandDeleteAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "guild_application_command_counts_update":
 				var counts = dat["application_command_counts"];
 				await this.OnGuildApplicationCommandCountsUpdateAsync((int)counts["1"], (int)counts["2"], (int)counts["3"], (ulong)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "guild_application_command_index_update":
 				// TODO: Implement.
 				break;
 
 			case "application_command_permissions_update":
 				var aid = (ulong)dat["application_id"];
 				if (aid != this.CurrentApplication.Id)
 					return;
 
 				var pms = dat["permissions"].ToObject<IEnumerable<DiscordApplicationCommandPermission>>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnApplicationCommandPermissionsUpdateAsync(pms, (ulong)dat["id"], gid, aid).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Misc
 
 			case "gift_code_update": //Not supposed to be dispatched to bots
 				break;
 
 			case "typing_start":
 				cid = (ulong)dat["channel_id"];
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				await this.OnTypingStartEventAsync((ulong)dat["user_id"], cid, this.InternalGetCachedChannel(cid), (ulong?)dat["guild_id"], Utilities.GetDateTimeOffset((long)dat["timestamp"]), mbr).ConfigureAwait(false);
 				break;
 
 			case "webhooks_update":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnWebhooksUpdateAsync(this.GuildsInternal[gid].GetChannel(cid), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			default:
 				await this.OnUnknownEventAsync(payload).ConfigureAwait(false);
 				this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Unknown event: {0}\npayload: {1}", payload.EventName, payload.Data);
 				break;
 
 				#endregion
 		}
 	}
 
 	#endregion
 
 	#region Events
 
 	#region Gateway
 
 	/// <summary>
 	/// Handles the ready event.
 	/// </summary>
 	/// <param name="ready">The ready payload.</param>
 	/// <param name="rawGuilds">The raw guilds.</param>
 	internal async Task OnReadyEventAsync(ReadyPayload ready, JArray rawGuilds)
 	{
 		//ready.CurrentUser.Discord = this;
 
 		var rusr = ready.CurrentUser;
 		this.CurrentUser.Username = rusr.Username;
 		this.CurrentUser.Discriminator = rusr.Discriminator;
 		this.CurrentUser.AvatarHash = rusr.AvatarHash;
 		this.CurrentUser.MfaEnabled = rusr.MfaEnabled;
 		this.CurrentUser.Verified = rusr.Verified;
 		this.CurrentUser.IsBot = rusr.IsBot;
 		this.CurrentUser.Flags = rusr.Flags;
 
 		this.GatewayVersion = ready.GatewayVersion;
 		this._sessionId = ready.SessionId;
 		var rawGuildIndex = rawGuilds.ToDictionary(xt => (ulong)xt["id"], xt => (JObject)xt);
 
 		this.GuildsInternal.Clear();
 		foreach (var guild in ready.Guilds)
 		{
 			guild.Discord = this;
 
 			if (guild.ChannelsInternal == null)
 				guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 
 			foreach (var xc in guild.Channels.Values)
 			{
 				xc.GuildId = guild.Id;
 				xc.Discord = this;
 				foreach (var xo in xc.PermissionOverwritesInternal)
 				{
 					xo.Discord = this;
 					xo.ChannelId = xc.Id;
 				}
 			}
 
 			if (guild.RolesInternal == null)
 				guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 
 			foreach (var xr in guild.Roles.Values)
 			{
 				xr.Discord = this;
 				xr.GuildId = guild.Id;
 			}
 
 			var rawGuild = rawGuildIndex[guild.Id];
 			var rawMembers = (JArray)rawGuild["members"];
 
 			if (guild.MembersInternal != null)
 				guild.MembersInternal.Clear();
 			else
 				guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 
 			if (rawMembers != null)
 			{
 				foreach (var xj in rawMembers)
 				{
 					var xtm = xj.ToObject<TransportMember>();
 
 					var xu = new DiscordUser(xtm.User) { Discord = this };
 					xu = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 					{
 						old.Username = xu.Username;
 						old.Discriminator = xu.Discriminator;
 						old.AvatarHash = xu.AvatarHash;
 						return old;
 					});
 
 					guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 				}
 			}
 
 			if (guild.EmojisInternal == null)
 				guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 
 			foreach (var xe in guild.Emojis.Values)
 				xe.Discord = this;
 
 			if (guild.StickersInternal == null)
 				guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 
 			foreach (var xs in guild.Stickers.Values)
 				xs.Discord = this;
 
 			if (guild.VoiceStatesInternal == null)
 				guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 
 			foreach (var xvs in guild.VoiceStates.Values)
 				xvs.Discord = this;
 
 			if (guild.ThreadsInternal == null)
 				guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 
 			foreach (var xt in guild.ThreadsInternal.Values)
 				xt.Discord = this;
 
 			if (guild.StageInstancesInternal == null)
 				guild.StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>();
 
 			foreach (var xsi in guild.StageInstancesInternal.Values)
 				xsi.Discord = this;
 
 			if (guild.ScheduledEventsInternal == null)
 				guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 			foreach (var xse in guild.ScheduledEventsInternal.Values)
 				xse.Discord = this;
 
 			this.GuildsInternal[guild.Id] = guild;
 		}
 
 		await this._ready.InvokeAsync(this, new ReadyEventArgs(this.ServiceProvider)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the resumed event.
 	/// </summary>
 	internal Task OnResumedAsync()
 	{
 		this.Logger.LogInformation(LoggerEvents.SessionUpdate, "Session resumed");
 		return this._resumed.InvokeAsync(this, new ReadyEventArgs(this.ServiceProvider));
 	}
 
 	#endregion
 
 	#region Channel
 
 	/// <summary>
 	/// Handles the channel create event.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal async Task OnChannelCreateEventAsync(DiscordChannel channel)
 	{
 		channel.Discord = this;
 		foreach (var xo in channel.PermissionOverwritesInternal)
 		{
 			xo.Discord = this;
 			xo.ChannelId = channel.Id;
 		}
 
 		this.GuildsInternal[channel.GuildId.Value].ChannelsInternal[channel.Id] = channel;
 
 		/*if (this.Configuration.AutoRefreshChannelCache)
             {
                 await this.RefreshChannelsAsync(channel.Guild.Id);
             }*/
 
 		await this._channelCreated.InvokeAsync(this, new ChannelCreateEventArgs(this.ServiceProvider) { Channel = channel, Guild = channel.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the channel update event.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal async Task OnChannelUpdateEventAsync(DiscordChannel channel)
 	{
 		if (channel == null)
 			return;
 
 		channel.Discord = this;
 
 		var gld = channel.Guild;
 
 		var channelNew = this.InternalGetCachedChannel(channel.Id);
 		DiscordChannel channelOld = null;
 
 		if (channelNew != null)
 		{
 			channelOld = new DiscordChannel
 			{
 				Bitrate = channelNew.Bitrate,
 				Discord = this,
 				GuildId = channelNew.GuildId,
 				Id = channelNew.Id,
 				LastMessageId = channelNew.LastMessageId,
 				Name = channelNew.Name,
 				PermissionOverwritesInternal = new List<DiscordOverwrite>(channelNew.PermissionOverwritesInternal),
 				Position = channelNew.Position,
 				Topic = channelNew.Topic,
 				Type = channelNew.Type,
 				UserLimit = channelNew.UserLimit,
 				ParentId = channelNew.ParentId,
 				IsNsfw = channelNew.IsNsfw,
 				PerUserRateLimit = channelNew.PerUserRateLimit,
 				RtcRegionId = channelNew.RtcRegionId,
 				QualityMode = channelNew.QualityMode,
 				DefaultAutoArchiveDuration = channelNew.DefaultAutoArchiveDuration
 			};
 
 			channelNew.Bitrate = channel.Bitrate;
 			channelNew.Name = channel.Name;
 			channelNew.Position = channel.Position;
 			channelNew.Topic = channel.Topic;
 			channelNew.UserLimit = channel.UserLimit;
 			channelNew.ParentId = channel.ParentId;
 			channelNew.IsNsfw = channel.IsNsfw;
 			channelNew.PerUserRateLimit = channel.PerUserRateLimit;
 			channelNew.Type = channel.Type;
 			channelNew.RtcRegionId = channel.RtcRegionId;
 			channelNew.QualityMode = channel.QualityMode;
 			channelNew.DefaultAutoArchiveDuration = channel.DefaultAutoArchiveDuration;
 
 			channelNew.PermissionOverwritesInternal.Clear();
 
 			foreach (var po in channel.PermissionOverwritesInternal)
 			{
 				po.Discord = this;
 				po.ChannelId = channel.Id;
 			}
 
 			channelNew.PermissionOverwritesInternal.AddRange(channel.PermissionOverwritesInternal);
 
 			if (this.Configuration.AutoRefreshChannelCache && gld != null)
 			{
 				await this.RefreshChannelsAsync(channel.Guild.Id);
 			}
 		}
 		else if (gld != null)
 		{
 			gld.ChannelsInternal[channel.Id] = channel;
 
 			if (this.Configuration.AutoRefreshChannelCache)
 			{
 				await this.RefreshChannelsAsync(channel.Guild.Id);
 			}
 		}
 
 		await this._channelUpdated.InvokeAsync(this, new ChannelUpdateEventArgs(this.ServiceProvider) { ChannelAfter = channelNew, Guild = gld, ChannelBefore = channelOld }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the channel delete event.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal async Task OnChannelDeleteEventAsync(DiscordChannel channel)
 	{
 		if (channel == null)
 			return;
 
 		channel.Discord = this;
 
 		//if (channel.IsPrivate)
 		if (channel.Type == ChannelType.Group || channel.Type == ChannelType.Private)
 		{
 			var dmChannel = channel as DiscordDmChannel;
 
 			await this._dmChannelDeleted.InvokeAsync(this, new DmChannelDeleteEventArgs(this.ServiceProvider) { Channel = dmChannel }).ConfigureAwait(false);
 		}
 		else
 		{
 			var gld = channel.Guild;
 
 			if (gld.ChannelsInternal.TryRemove(channel.Id, out var cachedChannel)) channel = cachedChannel;
 
 			if (this.Configuration.AutoRefreshChannelCache)
 			{
 				await this.RefreshChannelsAsync(channel.Guild.Id);
 			}
 
 			await this._channelDeleted.InvokeAsync(this, new ChannelDeleteEventArgs(this.ServiceProvider) { Channel = channel, Guild = gld }).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Refreshes the channels.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	internal async Task RefreshChannelsAsync(ulong guildId)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channels = await this.ApiClient.GetGuildChannelsAsync(guildId);
 		guild.ChannelsInternal.Clear();
 		foreach (var channel in channels.ToList())
 		{
 			channel.Discord = this;
 			foreach (var xo in channel.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = channel.Id;
 			}
 			guild.ChannelsInternal[channel.Id] = channel;
 		}
 	}
 
 	/// <summary>
 	/// Handles the channel pins update event.
 	/// </summary>
 	/// <param name="guildId">The optional guild id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="lastPinTimestamp">The optional last pin timestamp.</param>
 	internal async Task OnChannelPinsUpdateAsync(ulong? guildId, ulong channelId, DateTimeOffset? lastPinTimestamp)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		var ea = new ChannelPinsUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Channel = channel,
 			LastPinTimestamp = lastPinTimestamp
 		};
 		await this._channelPinsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild
 
 	/// <summary>
 	/// Handles the guild create event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	/// <param name="presences">The presences.</param>
 	internal async Task OnGuildCreateEventAsync(DiscordGuild guild, JArray rawMembers, IEnumerable<DiscordPresence> presences)
 	{
 		if (presences != null)
 		{
 			foreach (var xp in presences)
 			{
 				xp.Discord = this;
 				xp.GuildId = guild.Id;
 				xp.Activity = new DiscordActivity(xp.RawActivity);
 				if (xp.RawActivities != null)
 				{
 					xp.InternalActivities = xp.RawActivities
 						.Select(x => new DiscordActivity(x)).ToArray();
 				}
 				this.PresencesInternal[xp.InternalUser.Id] = xp;
 			}
 		}
 
 		var exists = this.GuildsInternal.TryGetValue(guild.Id, out var foundGuild);
 
 		guild.Discord = this;
 		guild.IsUnavailable = false;
 		var eventGuild = guild;
 		if (exists)
 			guild = foundGuild;
 
 		if (guild.ChannelsInternal == null)
 			guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 		if (guild.ThreadsInternal == null)
 			guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		if (guild.RolesInternal == null)
 			guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 		if (guild.ThreadsInternal == null)
 			guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		if (guild.StickersInternal == null)
 			guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 		if (guild.EmojisInternal == null)
 			guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 		if (guild.VoiceStatesInternal == null)
 			guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 		if (guild.MembersInternal == null)
 			guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 		if (guild.ScheduledEventsInternal == null)
 			guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 		this.UpdateCachedGuild(eventGuild, rawMembers);
 
 		guild.JoinedAt = eventGuild.JoinedAt;
 		guild.IsLarge = eventGuild.IsLarge;
 		guild.MemberCount = Math.Max(eventGuild.MemberCount, guild.MembersInternal.Count);
 		guild.IsUnavailable = eventGuild.IsUnavailable;
 		guild.PremiumSubscriptionCount = eventGuild.PremiumSubscriptionCount;
 		guild.PremiumTier = eventGuild.PremiumTier;
 		guild.BannerHash = eventGuild.BannerHash;
 		guild.VanityUrlCode = eventGuild.VanityUrlCode;
 		guild.Description = eventGuild.Description;
 		guild.IsNsfw = eventGuild.IsNsfw;
 
 		foreach (var kvp in eventGuild.VoiceStatesInternal) guild.VoiceStatesInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.ChannelsInternal) guild.ChannelsInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.RolesInternal) guild.RolesInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.EmojisInternal) guild.EmojisInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.ThreadsInternal) guild.ThreadsInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.StickersInternal) guild.StickersInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.StageInstancesInternal) guild.StageInstancesInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.ScheduledEventsInternal) guild.ScheduledEventsInternal[kvp.Key] = kvp.Value;
 
 		foreach (var xc in guild.ChannelsInternal.Values)
 		{
 			xc.GuildId = guild.Id;
 			xc.Discord = this;
 			foreach (var xo in xc.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = xc.Id;
 			}
 		}
 		foreach (var xt in guild.ThreadsInternal.Values)
 		{
 			xt.GuildId = guild.Id;
 			xt.Discord = this;
 		}
 		foreach (var xe in guild.EmojisInternal.Values)
 			xe.Discord = this;
 		foreach (var xs in guild.StickersInternal.Values)
 			xs.Discord = this;
 		foreach (var xvs in guild.VoiceStatesInternal.Values)
 			xvs.Discord = this;
 		foreach (var xsi in guild.StageInstancesInternal.Values)
 		{
 			xsi.Discord = this;
 			xsi.GuildId = guild.Id;
 		}
 		foreach (var xr in guild.RolesInternal.Values)
 		{
 			xr.Discord = this;
 			xr.GuildId = guild.Id;
 		}
 		foreach (var xse in guild.ScheduledEventsInternal.Values)
 		{
 			xse.Discord = this;
 			xse.GuildId = guild.Id;
 			if (xse.Creator != null)
 				xse.Creator.Discord = this;
 		}
 
 		var old = Volatile.Read(ref this._guildDownloadCompleted);
 		var dcompl = this.GuildsInternal.Values.All(xg => !xg.IsUnavailable);
 		Volatile.Write(ref this._guildDownloadCompleted, dcompl);
 
 		if (exists)
 			await this._guildAvailable.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 		else
 			await this._guildCreated.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 
 		if (dcompl && !old)
 			await this._guildDownloadCompletedEv.InvokeAsync(this, new GuildDownloadCompletedEventArgs(this.Guilds, this.ServiceProvider)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	internal async Task OnGuildUpdateEventAsync(DiscordGuild guild, JArray rawMembers)
 	{
 		DiscordGuild oldGuild;
 
 		if (!this.GuildsInternal.ContainsKey(guild.Id))
 		{
 			this.GuildsInternal[guild.Id] = guild;
 			oldGuild = null;
 		}
 		else
 		{
 			var gld = this.GuildsInternal[guild.Id];
 
 			oldGuild = new DiscordGuild
 			{
 				Discord = gld.Discord,
 				Name = gld.Name,
 				AfkChannelId = gld.AfkChannelId,
 				AfkTimeout = gld.AfkTimeout,
 				ApplicationId = gld.ApplicationId,
 				DefaultMessageNotifications = gld.DefaultMessageNotifications,
 				ExplicitContentFilter = gld.ExplicitContentFilter,
 				RawFeatures = gld.RawFeatures,
 				IconHash = gld.IconHash,
 				Id = gld.Id,
 				IsLarge = gld.IsLarge,
 				IsSynced = gld.IsSynced,
 				IsUnavailable = gld.IsUnavailable,
 				JoinedAt = gld.JoinedAt,
 				MemberCount = gld.MemberCount,
 				MaxMembers = gld.MaxMembers,
 				MaxPresences = gld.MaxPresences,
 				ApproximateMemberCount = gld.ApproximateMemberCount,
 				ApproximatePresenceCount = gld.ApproximatePresenceCount,
 				MaxVideoChannelUsers = gld.MaxVideoChannelUsers,
 				DiscoverySplashHash = gld.DiscoverySplashHash,
 				PreferredLocale = gld.PreferredLocale,
 				MfaLevel = gld.MfaLevel,
 				OwnerId = gld.OwnerId,
 				SplashHash = gld.SplashHash,
 				SystemChannelId = gld.SystemChannelId,
 				SystemChannelFlags = gld.SystemChannelFlags,
 				Description = gld.Description,
 				WidgetEnabled = gld.WidgetEnabled,
 				WidgetChannelId = gld.WidgetChannelId,
 				VerificationLevel = gld.VerificationLevel,
 				RulesChannelId = gld.RulesChannelId,
 				PublicUpdatesChannelId = gld.PublicUpdatesChannelId,
 				VoiceRegionId = gld.VoiceRegionId,
 				IsNsfw = gld.IsNsfw,
 				PremiumProgressBarEnabled = gld.PremiumProgressBarEnabled,
 				PremiumSubscriptionCount = gld.PremiumSubscriptionCount,
 				PremiumTier = gld.PremiumTier,
 				ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>(),
 				ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>(),
 				EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>(),
 				StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>(),
 				MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>(),
 				RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>(),
 				StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>(),
 				VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>(),
 				ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>()
 			};
 
 			foreach (var kvp in gld.ChannelsInternal) oldGuild.ChannelsInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.ThreadsInternal) oldGuild.ThreadsInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.EmojisInternal) oldGuild.EmojisInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.StickersInternal) oldGuild.StickersInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.RolesInternal) oldGuild.RolesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.VoiceStatesInternal) oldGuild.VoiceStatesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.MembersInternal) oldGuild.MembersInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.StageInstancesInternal) oldGuild.StageInstancesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.ScheduledEventsInternal) oldGuild.ScheduledEventsInternal[kvp.Key] = kvp.Value;
 		}
 
 		guild.Discord = this;
 		guild.IsUnavailable = false;
 		var eventGuild = guild;
 		guild = this.GuildsInternal[eventGuild.Id];
 
 		if (guild.ChannelsInternal == null)
 			guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 		if (guild.ThreadsInternal == null)
 			guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		if (guild.RolesInternal == null)
 			guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 		if (guild.EmojisInternal == null)
 			guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 		if (guild.StickersInternal == null)
 			guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 		if (guild.VoiceStatesInternal == null)
 			guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 		if (guild.StageInstancesInternal == null)
 			guild.StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>();
 		if (guild.MembersInternal == null)
 			guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 		if (guild.ScheduledEventsInternal == null)
 			guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 		this.UpdateCachedGuild(eventGuild, rawMembers);
 
 		foreach (var xc in guild.ChannelsInternal.Values)
 		{
 			xc.GuildId = guild.Id;
 			xc.Discord = this;
 			foreach (var xo in xc.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = xc.Id;
 			}
 		}
 		foreach (var xc in guild.ThreadsInternal.Values)
 		{
 			xc.GuildId = guild.Id;
 			xc.Discord = this;
 		}
 		foreach (var xe in guild.EmojisInternal.Values)
 			xe.Discord = this;
 		foreach (var xs in guild.StickersInternal.Values)
 			xs.Discord = this;
 		foreach (var xvs in guild.VoiceStatesInternal.Values)
 			xvs.Discord = this;
 		foreach (var xr in guild.RolesInternal.Values)
 		{
 			xr.Discord = this;
 			xr.GuildId = guild.Id;
 		}
 		foreach (var xsi in guild.StageInstancesInternal.Values)
 		{
 			xsi.Discord = this;
 			xsi.GuildId = guild.Id;
 		}
 		foreach (var xse in guild.ScheduledEventsInternal.Values)
 		{
 			xse.Discord = this;
 			xse.GuildId = guild.Id;
 			if (xse.Creator != null)
 				xse.Creator.Discord = this;
 		}
 
 		await this._guildUpdated.InvokeAsync(this, new GuildUpdateEventArgs(this.ServiceProvider) { GuildBefore = oldGuild, GuildAfter = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild delete event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildDeleteEventAsync(DiscordGuild guild)
 	{
 		if (guild.IsUnavailable)
 		{
 			if (!this.GuildsInternal.TryGetValue(guild.Id, out var gld))
 				return;
 
 			gld.IsUnavailable = true;
 
 			await this._guildUnavailable.InvokeAsync(this, new GuildDeleteEventArgs(this.ServiceProvider) { Guild = guild, Unavailable = true }).ConfigureAwait(false);
 		}
 		else
 		{
 			if (!this.GuildsInternal.TryRemove(guild.Id, out var gld))
 				return;
 
 			await this._guildDeleted.InvokeAsync(this, new GuildDeleteEventArgs(this.ServiceProvider) { Guild = gld }).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Handles the guild sync event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="isLarge">Whether the guild is a large guild..</param>
 	/// <param name="rawMembers">The raw members.</param>
 	/// <param name="presences">The presences.</param>
 	internal async Task OnGuildSyncEventAsync(DiscordGuild guild, bool isLarge, JArray rawMembers, IEnumerable<DiscordPresence> presences)
 	{
 		presences = presences.Select(xp => { xp.Discord = this; xp.Activity = new DiscordActivity(xp.RawActivity); return xp; });
 		foreach (var xp in presences)
 			this.PresencesInternal[xp.InternalUser.Id] = xp;
 
 		guild.IsSynced = true;
 		guild.IsLarge = isLarge;
 
 		this.UpdateCachedGuild(guild, rawMembers);
 
 		await this._guildAvailable.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild emojis update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="newEmojis">The new emojis.</param>
 	internal async Task OnGuildEmojisUpdateEventAsync(DiscordGuild guild, IEnumerable<DiscordEmoji> newEmojis)
 	{
 		var oldEmojis = new ConcurrentDictionary<ulong, DiscordEmoji>(guild.EmojisInternal);
 		guild.EmojisInternal.Clear();
 
 		foreach (var emoji in newEmojis)
 		{
 			emoji.Discord = this;
 			guild.EmojisInternal[emoji.Id] = emoji;
 		}
 
 		var ea = new GuildEmojisUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			EmojisAfter = guild.Emojis,
 			EmojisBefore = new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(oldEmojis)
 		};
 		await this._guildEmojisUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the stickers updated.
 	/// </summary>
 	/// <param name="newStickers">The new stickers.</param>
 	/// <param name="guildId">The guild id.</param>
 	internal async Task OnStickersUpdatedAsync(IEnumerable<DiscordSticker> newStickers, ulong guildId)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var oldStickers = new ConcurrentDictionary<ulong, DiscordSticker>(guild.StickersInternal);
 		guild.StickersInternal.Clear();
 
 		foreach (var nst in newStickers)
 		{
 			if (nst.User is not null)
 			{
 				nst.User.Discord = this;
 				this.UserCache.AddOrUpdate(nst.User.Id, nst.User, (old, @new) => @new);
 			}
 			nst.Discord = this;
 
 			guild.StickersInternal[nst.Id] = nst;
 		}
 
 		var sea = new GuildStickersUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			StickersBefore = oldStickers,
 			StickersAfter = guild.Stickers
 		};
 
 		await this._guildStickersUpdated.InvokeAsync(this, sea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Ban
 
 	/// <summary>
 	/// Handles the guild ban add event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildBanAddEventAsync(TransportUser user, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(user.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		if (!guild.Members.TryGetValue(user.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		var ea = new GuildBanAddEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildBanAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild ban remove event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildBanRemoveEventAsync(TransportUser user, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(user.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		if (!guild.Members.TryGetValue(user.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		var ea = new GuildBanRemoveEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildBanRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Scheduled Event
 
 	/// <summary>
 	/// Handles the scheduled event create event.
 	/// </summary>
 	/// <param name="scheduledEvent">The created event.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildScheduledEventCreateEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		scheduledEvent.Discord = this;
 
 		guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (old, newScheduledEvent) => newScheduledEvent);
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this;
 			this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		await this._guildScheduledEventCreated.InvokeAsync(this, new GuildScheduledEventCreateEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = scheduledEvent.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the scheduled event update event.
 	/// </summary>
 	/// <param name="scheduledEvent">The updated event.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildScheduledEventUpdateEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		if (guild == null)
 			return;
 
 		DiscordScheduledEvent oldEvent;
 		if (!guild.ScheduledEventsInternal.ContainsKey(scheduledEvent.Id))
 		{
 			oldEvent = null;
 		}
 		else
 		{
 			var ev = guild.ScheduledEventsInternal[scheduledEvent.Id];
 			oldEvent = new DiscordScheduledEvent
 			{
 				Id = ev.Id,
 				ChannelId = ev.ChannelId,
 				EntityId = ev.EntityId,
 				EntityMetadata = ev.EntityMetadata,
 				CreatorId = ev.CreatorId,
 				Creator = ev.Creator,
 				Discord = this,
 				Description = ev.Description,
 				EntityType = ev.EntityType,
 				ScheduledStartTimeRaw = ev.ScheduledStartTimeRaw,
 				ScheduledEndTimeRaw = ev.ScheduledEndTimeRaw,
 				GuildId = ev.GuildId,
 				Status = ev.Status,
 				Name = ev.Name,
 				UserCount = ev.UserCount,
 				CoverImageHash = ev.CoverImageHash
 			};
 
 		}
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this;
 			this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		if (scheduledEvent.Status == ScheduledEventStatus.Completed)
 		{
 			guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 			await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, Reason = ScheduledEventStatus.Completed }).ConfigureAwait(false);
 		}
 		else if (scheduledEvent.Status == ScheduledEventStatus.Canceled)
 		{
 			guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 			scheduledEvent.Status = ScheduledEventStatus.Canceled;
 			await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, Reason = ScheduledEventStatus.Canceled }).ConfigureAwait(false);
 		}
 		else
 		{
 			this.UpdateScheduledEvent(scheduledEvent, guild);
 			await this._guildScheduledEventUpdated.InvokeAsync(this, new GuildScheduledEventUpdateEventArgs(this.ServiceProvider) { ScheduledEventBefore = oldEvent, ScheduledEventAfter = scheduledEvent, Guild = guild }).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Handles the scheduled event delete event.
 	/// </summary>
 	/// <param name="scheduledEvent">The deleted event.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildScheduledEventDeleteEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		scheduledEvent.Discord = this;
 
 		if (scheduledEvent.Status == ScheduledEventStatus.Scheduled)
 			scheduledEvent.Status = ScheduledEventStatus.Canceled;
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this;
 			this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = scheduledEvent.Guild, Reason = scheduledEvent.Status }).ConfigureAwait(false);
 		guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 	}
 
 	/// <summary>
 	/// Handles the scheduled event user add event.
 	/// <param name="guildScheduledEventId">The event.</param>
 	/// <param name="userId">The added user id.</param>
 	/// <param name="guild">The guild.</param>
 	/// </summary>
 	internal async Task OnGuildScheduledEventUserAddedEventAsync(ulong guildScheduledEventId, ulong userId, DiscordGuild guild)
 	{
 		var scheduledEvent = this.InternalGetCachedScheduledEvent(guildScheduledEventId) ?? this.UpdateScheduledEvent(new DiscordScheduledEvent
 		{
 			Id = guildScheduledEventId,
 			GuildId = guild.Id,
 			Discord = this,
 			UserCount = 0
 		}, guild);
 
 		scheduledEvent.UserCount++;
 		scheduledEvent.Discord = this;
 		guild.Discord = this;
 
 		var user = this.GetUserAsync(userId, true).Result;
 		user.Discord = this;
 		var member = guild.Members.TryGetValue(userId, out var mem) ? mem : guild.GetMemberAsync(userId).Result;
 		member.Discord = this;
 
 		await this._guildScheduledEventUserAdded.InvokeAsync(this, new GuildScheduledEventUserAddEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, User = user, Member = member }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the scheduled event user remove event.
 	/// <param name="guildScheduledEventId">The event.</param>
 	/// <param name="userId">The removed user id.</param>
 	/// <param name="guild">The guild.</param>
 	/// </summary>
 	internal async Task OnGuildScheduledEventUserRemovedEventAsync(ulong guildScheduledEventId, ulong userId, DiscordGuild guild)
 	{
 		var scheduledEvent = this.InternalGetCachedScheduledEvent(guildScheduledEventId) ?? this.UpdateScheduledEvent(new DiscordScheduledEvent
 		{
 			Id = guildScheduledEventId,
 			GuildId = guild.Id,
 			Discord = this,
 			UserCount = 0
 		}, guild);
 
 		scheduledEvent.UserCount = scheduledEvent.UserCount == 0 ? 0 : scheduledEvent.UserCount - 1;
 		scheduledEvent.Discord = this;
 		guild.Discord = this;
 
 		var user = this.GetUserAsync(userId, true).Result;
 		user.Discord = this;
 		var member = guild.Members.TryGetValue(userId, out var mem) ? mem : guild.GetMemberAsync(userId).Result;
 		member.Discord = this;
 
 		await this._guildScheduledEventUserRemoved.InvokeAsync(this, new GuildScheduledEventUserRemoveEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, User = user, Member = member }).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Integration
 
 	/// <summary>
 	/// Handles the guild integration create event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="integration">The integration.</param>
 	internal async Task OnGuildIntegrationCreateEventAsync(DiscordGuild guild, DiscordIntegration integration)
 	{
 		integration.Discord = this;
 
 		await this._guildIntegrationCreated.InvokeAsync(this, new GuildIntegrationCreateEventArgs(this.ServiceProvider) { Integration = integration, Guild = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild integration update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="integration">The integration.</param>
 	internal async Task OnGuildIntegrationUpdateEventAsync(DiscordGuild guild, DiscordIntegration integration)
 	{
 		integration.Discord = this;
 
 		await this._guildIntegrationUpdated.InvokeAsync(this, new GuildIntegrationUpdateEventArgs(this.ServiceProvider) { Integration = integration, Guild = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild integrations update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildIntegrationsUpdateEventAsync(DiscordGuild guild)
 	{
 		var ea = new GuildIntegrationsUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild
 		};
 		await this._guildIntegrationsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild integration delete event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="integrationId">The integration id.</param>
 	/// <param name="applicationId">The optional application id.</param>
 	internal async Task OnGuildIntegrationDeleteEventAsync(DiscordGuild guild, ulong integrationId, ulong? applicationId)
 		=> await this._guildIntegrationDeleted.InvokeAsync(this, new GuildIntegrationDeleteEventArgs(this.ServiceProvider) { Guild = guild, IntegrationId = integrationId, ApplicationId = applicationId }).ConfigureAwait(false);
 
 	#endregion
 
 	#region Guild Member
 
 	/// <summary>
 	/// Handles the guild member add event.
 	/// </summary>
 	/// <param name="member">The transport member.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildMemberAddEventAsync(TransportMember member, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(member.User) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(member.User.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		var mbr = new DiscordMember(member)
 		{
 			Discord = this,
 			GuildId = guild.Id
 		};
 
 		guild.MembersInternal[mbr.Id] = mbr;
 		guild.MemberCount++;
 
 		var ea = new GuildMemberAddEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildMemberAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild member remove event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildMemberRemoveEventAsync(TransportUser user, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(user);
 
 		if (!guild.MembersInternal.TryRemove(user.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		guild.MemberCount--;
 
 		_ = this.UserCache.AddOrUpdate(user.Id, usr, (old, @new) => @new);
 
 		var ea = new GuildMemberRemoveEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildMemberRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild member update event.
 	/// </summary>
 	/// <param name="member">The transport member.</param>
 	/// <param name="guild">The guild.</param>
 	/// <param name="roles">The roles.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="pending">Whether the member is pending.</param>
 	internal async Task OnGuildMemberUpdateEventAsync(TransportMember member, DiscordGuild guild, IEnumerable<ulong> roles, string nick, bool? pending)
 	{
 		var usr = new DiscordUser(member.User) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		if (!guild.Members.TryGetValue(member.User.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		var old = mbr;
 
 		var gAvOld = old.GuildAvatarHash;
 		var avOld = old.AvatarHash;
 		var nickOld = mbr.Nickname;
 		var pendingOld = mbr.IsPending;
 		var rolesOld = new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(mbr.Roles));
 		var cduOld = mbr.CommunicationDisabledUntil;
 		mbr.MemberFlags = member.MemberFlags;
 		mbr.AvatarHashInternal = member.AvatarHash;
 		mbr.GuildAvatarHash = member.GuildAvatarHash;
 		mbr.Nickname = nick;
 		mbr.GuildPronouns = member.GuildPronouns;
 		mbr.IsPending = pending;
 		mbr.CommunicationDisabledUntil = member.CommunicationDisabledUntil;
 		mbr.RoleIdsInternal.Clear();
 		mbr.RoleIdsInternal.AddRange(roles);
 		guild.MembersInternal.AddOrUpdate(member.User.Id, mbr, (id, oldMbr) => oldMbr);
 
 		var timeoutUntil = member.CommunicationDisabledUntil;
 		/*this.Logger.LogTrace($"Timeout:\nBefore - {cduOld}\nAfter - {timeoutUntil}");
 		if ((timeoutUntil.HasValue && cduOld.HasValue) || (timeoutUntil == null && cduOld.HasValue) || (timeoutUntil.HasValue && cduOld == null))
 		{
 			// We are going to add a scheduled timer to assure that we get a auditlog entry.
 
 			var id = $"tt-{mbr.Id}-{guild.Id}-{DateTime.Now.ToLongTimeString()}";
 
 			this._tempTimers.Add(
 				id,
 				new(
 					new TimeoutHandler(
 						mbr,
 						guild,
 						cduOld,
 						timeoutUntil
 					),
 					new Timer(
 						this.TimeoutTimer,
 						id,
 						2000,
 						Timeout.Infinite
 					)
 				)
 			);
 
 			this.Logger.LogTrace("Scheduling timeout event.");
 
 			return;
 		}*/
 
 		//this.Logger.LogTrace("No timeout detected. Continuing on normal operation.");
 
 		var eargs = new GuildMemberUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr,
 
 			NicknameAfter = mbr.Nickname,
 			RolesAfter = new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(mbr.Roles)),
 			PendingAfter = mbr.IsPending,
 			TimeoutAfter = mbr.CommunicationDisabledUntil,
 			AvatarHashAfter = mbr.AvatarHash,
 			GuildAvatarHashAfter = mbr.GuildAvatarHash,
 
 			NicknameBefore = nickOld,
 			RolesBefore = rolesOld,
 			PendingBefore = pendingOld,
 			TimeoutBefore = cduOld,
 			AvatarHashBefore = avOld,
 			GuildAvatarHashBefore = gAvOld
 		};
 		await this._guildMemberUpdated.InvokeAsync(this, eargs).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles timeout events.
 	/// </summary>
 	/// <param name="state">Internally used as uid for the timer data.</param>
 	private async void TimeoutTimer(object state)
 	{
 		var tid = (string)state;
 		var data = this._tempTimers.First(x=> x.Key == tid).Value.Key;
 		var timer = this._tempTimers.First(x=> x.Key == tid).Value.Value;
 
 		IReadOnlyList<DiscordAuditLogEntry> auditlog = null;
 		DiscordAuditLogMemberUpdateEntry filtered = null;
 		try
 		{
 			auditlog = await data.Guild.GetAuditLogsAsync(10, null, AuditLogActionType.MemberUpdate);
 			var preFiltered = auditlog.Select(x => x as DiscordAuditLogMemberUpdateEntry).Where(x => x.Target.Id == data.Member.Id);
 			filtered = preFiltered.First();
 		}
 		catch (UnauthorizedException) { }
 		catch (Exception)
 		{
 			this.Logger.LogTrace("Failing timeout event.");
 			await timer.DisposeAsync();
 			this._tempTimers.Remove(tid);
 			return;
 		}
 
 		var actor = filtered?.UserResponsible as DiscordMember;
 
 		this.Logger.LogTrace("Trying to execute timeout event.");
 
 		if (data.TimeoutUntilOld.HasValue && data.TimeoutUntilNew.HasValue)
 		{
 			// A timeout was updated.
 
 			if (filtered != null && auditlog == null)
 			{
 				this.Logger.LogTrace("Re-scheduling timeout event.");
 				timer.Change(2000, Timeout.Infinite);
 				return;
 			}
 
 			var ea = new GuildMemberTimeoutUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = data.Guild,
 				Target = data.Member,
 				TimeoutBefore = data.TimeoutUntilOld.Value,
 				TimeoutAfter = data.TimeoutUntilNew.Value,
 				Actor = actor,
 				AuditLogId = filtered?.Id,
 				AuditLogReason = filtered?.Reason
 			};
 			await this._guildMemberTimeoutChanged.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 		else if (!data.TimeoutUntilOld.HasValue && data.TimeoutUntilNew.HasValue)
 		{
 			// A timeout was added.
 
 			if (filtered != null && auditlog == null)
 			{
 				this.Logger.LogTrace("Re-scheduling timeout event.");
 				timer.Change(2000, Timeout.Infinite);
 				return;
 			}
 
 			var ea = new GuildMemberTimeoutAddEventArgs(this.ServiceProvider)
 			{
 				Guild = data.Guild,
 				Target = data.Member,
 				Timeout = data.TimeoutUntilNew.Value,
 				Actor = actor,
 				AuditLogId = filtered?.Id,
 				AuditLogReason = filtered?.Reason
 			};
 			await this._guildMemberTimeoutAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 		else if (data.TimeoutUntilOld.HasValue && !data.TimeoutUntilNew.HasValue)
 		{
 			// A timeout was removed.
 
 			if (filtered != null && auditlog == null)
 			{
 				this.Logger.LogTrace("Re-scheduling timeout event.");
 				timer.Change(2000, Timeout.Infinite);
 				return;
 			}
 
 			var ea = new GuildMemberTimeoutRemoveEventArgs(this.ServiceProvider)
 			{
 				Guild = data.Guild,
 				Target = data.Member,
 				TimeoutBefore = data.TimeoutUntilOld.Value,
 				Actor = actor,
 				AuditLogId = filtered?.Id,
 				AuditLogReason = filtered?.Reason
 			};
 			await this._guildMemberTimeoutRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		// Ending timer because it worked.
 		this.Logger.LogTrace("Removing timeout event.");
 		await timer.DisposeAsync();
 		this._tempTimers.Remove(tid);
 	}
 
 	/// <summary>
 	/// Handles the guild members chunk event.
 	/// </summary>
 	/// <param name="dat">The raw chunk data.</param>
 	internal async Task OnGuildMembersChunkEventAsync(JObject dat)
 	{
 		var guild = this.Guilds[(ulong)dat["guild_id"]];
 		var chunkIndex = (int)dat["chunk_index"];
 		var chunkCount = (int)dat["chunk_count"];
 		var nonce = (string)dat["nonce"];
 
 		var mbrs = new HashSet<DiscordMember>();
 		var pres = new HashSet<DiscordPresence>();
 
 		var members = dat["members"].ToObject<TransportMember[]>();
 
 		foreach (var member in members)
 		{
 			var mbr = new DiscordMember(member) { Discord = this, GuildId = guild.Id };
 
 			if (!this.UserCache.ContainsKey(mbr.Id))
 				this.UserCache[mbr.Id] = new DiscordUser(member.User) { Discord = this };
 
 			guild.MembersInternal[mbr.Id] = mbr;
 
 			mbrs.Add(mbr);
 		}
 
 		guild.MemberCount = guild.MembersInternal.Count;
 
 		var ea = new GuildMembersChunkEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Members = new ReadOnlySet<DiscordMember>(mbrs),
 			ChunkIndex = chunkIndex,
 			ChunkCount = chunkCount,
 			Nonce = nonce,
 		};
 
 		if (dat["presences"] != null)
 		{
 			var presences = dat["presences"].ToObject<DiscordPresence[]>();
 
 			var presCount = presences.Length;
 			foreach (var presence in presences)
 			{
 				presence.Discord = this;
 				presence.Activity = new DiscordActivity(presence.RawActivity);
 
 				if (presence.RawActivities != null)
 				{
 					presence.InternalActivities = presence.RawActivities
 						.Select(x => new DiscordActivity(x)).ToArray();
 				}
 
 				pres.Add(presence);
 			}
 
 			ea.Presences = new ReadOnlySet<DiscordPresence>(pres);
 		}
 
 		if (dat["not_found"] != null)
 		{
 			var nf = dat["not_found"].ToObject<ISet<ulong>>();
 			ea.NotFound = new ReadOnlySet<ulong>(nf);
 		}
 
 		await this._guildMembersChunked.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Role
 
 	/// <summary>
 	/// Handles the guild role create event.
 	/// </summary>
 	/// <param name="role">The role.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildRoleCreateEventAsync(DiscordRole role, DiscordGuild guild)
 	{
 		role.Discord = this;
 		role.GuildId = guild.Id;
 
 		guild.RolesInternal[role.Id] = role;
 
 		var ea = new GuildRoleCreateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Role = role
 		};
 		await this._guildRoleCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild role update event.
 	/// </summary>
 	/// <param name="role">The role.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildRoleUpdateEventAsync(DiscordRole role, DiscordGuild guild)
 	{
 		var newRole = guild.GetRole(role.Id);
 		var oldRole = new DiscordRole
 		{
 			GuildId = guild.Id,
 			ColorInternal = newRole.ColorInternal,
 			Discord = this,
 			IsHoisted = newRole.IsHoisted,
 			Id = newRole.Id,
 			IsManaged = newRole.IsManaged,
 			IsMentionable = newRole.IsMentionable,
 			Name = newRole.Name,
 			Permissions = newRole.Permissions,
 			Position = newRole.Position,
 			IconHash = newRole.IconHash,
 			Tags = newRole.Tags ?? null,
 			UnicodeEmojiString = newRole.UnicodeEmojiString
 		};
 
 		newRole.GuildId = guild.Id;
 		newRole.ColorInternal = role.ColorInternal;
 		newRole.IsHoisted = role.IsHoisted;
 		newRole.IsManaged = role.IsManaged;
 		newRole.IsMentionable = role.IsMentionable;
 		newRole.Name = role.Name;
 		newRole.Permissions = role.Permissions;
 		newRole.Position = role.Position;
 		newRole.IconHash = role.IconHash;
 		newRole.Tags = role.Tags ?? null;
 		newRole.UnicodeEmojiString = role.UnicodeEmojiString;
 
 		var ea = new GuildRoleUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			RoleAfter = newRole,
 			RoleBefore = oldRole
 		};
 		await this._guildRoleUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild role delete event.
 	/// </summary>
 	/// <param name="roleId">The role id.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildRoleDeleteEventAsync(ulong roleId, DiscordGuild guild)
 	{
 		if (!guild.RolesInternal.TryRemove(roleId, out var role))
 			this.Logger.LogWarning($"Attempted to delete a nonexistent role ({roleId}) from guild ({guild}).");
 
 		var ea = new GuildRoleDeleteEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Role = role
 		};
 		await this._guildRoleDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Invite
 
 	/// <summary>
 	/// Handles the invite create event.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="invite">The invite.</param>
 	internal async Task OnInviteCreateEventAsync(ulong channelId, ulong guildId, DiscordInvite invite)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId);
 
 		invite.Discord = this;
 
 		if (invite.Inviter is not null)
 		{
 			invite.Inviter.Discord = this;
 			this.UserCache.AddOrUpdate(invite.Inviter.Id, invite.Inviter, (old, @new) => @new);
 		}
 
 		guild.Invites[invite.Code] = invite;
 
 		var ea = new InviteCreateEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild,
 			Invite = invite
 		};
 		await this._inviteCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the invite delete event.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="dat">The raw invite.</param>
 	internal async Task OnInviteDeleteEventAsync(ulong channelId, ulong guildId, JToken dat)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId);
 
 		if (!guild.Invites.TryRemove(dat["code"].ToString(), out var invite))
 		{
 			invite = dat.ToObject<DiscordInvite>();
 			invite.Discord = this;
 		}
 
 		invite.IsRevoked = true;
 
 		var ea = new InviteDeleteEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild,
 			Invite = invite
 		};
 		await this._inviteDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Message
 
 	/// <summary>
 	/// Handles the message acknowledge event.
 	/// </summary>
 	/// <param name="chn">The channel.</param>
 	/// <param name="messageId">The message id.</param>
 	internal async Task OnMessageAckEventAsync(DiscordChannel chn, ulong messageId)
 	{
-		if (this.MessageCache == null || !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == chn.Id, out var msg))
+		if (this.MessageCache == null || !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == chn.Id, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = chn.Id,
 				Discord = this,
 			};
 		}
 
 		await this._messageAcknowledged.InvokeAsync(this, new MessageAcknowledgeEventArgs(this.ServiceProvider) { Message = msg }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message create event.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The transport user (author).</param>
 	/// <param name="member">The transport member.</param>
 	/// <param name="referenceAuthor">The reference transport user (author).</param>
 	/// <param name="referenceMember">The reference transport member.</param>
 	internal async Task OnMessageCreateEventAsync(DiscordMessage message, TransportUser author, TransportMember member, TransportUser referenceAuthor, TransportMember referenceMember)
 	{
 		message.Discord = this;
 		this.PopulateMessageReactionsAndCache(message, author, member);
 		message.PopulateMentions();
 
 		if (message.Channel == null && message.ChannelId == default)
 			this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Channel which the last message belongs to is not in cache - cache state might be invalid!");
 
 		if (message.ReferencedMessage != null)
 		{
 			message.ReferencedMessage.Discord = this;
 			this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
 			message.ReferencedMessage.PopulateMentions();
 		}
 
 		foreach (var sticker in message.Stickers)
 			sticker.Discord = this;
 
 		var ea = new MessageCreateEventArgs(this.ServiceProvider)
 		{
 			Message = message,
-
-			MentionedUsers = new ReadOnlyCollection<DiscordUser>(message.MentionedUsersInternal),
-			MentionedRoles = message.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(message.MentionedRolesInternal) : null,
-			MentionedChannels = message.MentionedChannelsInternal != null ? new ReadOnlyCollection<DiscordChannel>(message.MentionedChannelsInternal) : null
+			MentionedUsers = message.MentionedUsers.ToList(),
+			MentionedRoles = message.MentionedRoles.ToList(),
+			MentionedChannels = message.MentionedChannels.ToList()
 		};
 		await this._messageCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
+	internal async Task OnMessageUpdateRaw(JObject data)
+	{
+		var guild = data["guild_id"];
+		if (guild.ToString() == "858089274087309313")
+			this.Logger.LogDebug(data.ToString());
+
+		// Valid
+
+
+		// To check
+		var rawRefMsg = data["referenced_message"];
+		TransportUser refUsr = null;
+		TransportMember refMbr = null;
+		
+
+		if (rawRefMsg != null && rawRefMsg.HasValues)
+		{
+			if (rawRefMsg.SelectToken("author") != null)
+			{
+				refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
+			}
+
+			if (rawRefMsg.SelectToken("member") != null)
+			{
+				refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
+			}
+		}
+
+		await this.OnMessageUpdateEventAsyncV2(data.ToDiscordObject<DiscordMessage>(), refUsr, refMbr).ConfigureAwait(false);
+	}
+
+	internal async Task OnMessageUpdateEventAsyncV2(DiscordMessage message, TransportUser referenceAuthor, TransportMember referenceMember)
+	{
+		DiscordMessage oldMessage = null;
+
+		message.Discord = this;
+
+		// If we have a guild id, we try to get the guild out of the cache, if not cached, we fetch from the api, otherwise null.
+		var guild = message.GuildId != null && message.GuildId.HasValue ?
+			this.InternalGetCachedGuild(message.GuildId) ?? await this.GetGuildAsync(message.GuildId.Value, false)
+			: null;
+
+		message.Guild = guild;
+
+		// We try to get the channel from the guild if guild id is given. This depends on the cache. If not cached, we fetch it from the api.
+		message.Channel = guild != null ?
+			this.InternalGetCachedChannel(message.ChannelId, guild.Id) ?? await this.ApiClient.GetChannelAsync(message.ChannelId)
+			: await this.ApiClient.GetChannelAsync(message.ChannelId);
+		
+		// When the message cache is not disabled and we get an old message
+		if (this.Configuration.MessageCacheSize != 0 && this.MessageCache != null && this.MessageCache.TryGetLastOrDefault(xm => xm.Id == message.Id && xm.ChannelId == message.ChannelId, out oldMessage))
+		{
+			oldMessage.Discord = this;
+			oldMessage.Guild = message.Guild;
+			oldMessage.Channel = message.Channel;
+		}
+
+		// If we have a transport member, we convert it to a discord member and update the members cache.
+		if (message.MemberInternal != null)
+		{
+			message.MemberInternal.User = message.AuthorInternal;
+			message.Member = new(message.MemberInternal)
+			{
+				Discord = this
+			};
+			guild.MembersInternal.AddOrUpdate(message.AuthorInternal.Id, message.Member, (id, oldMbr) => oldMbr);
+		}
+
+		this.PopulateMessageReactionsAndCache(message, message.AuthorInternal, message.MemberInternal);
+
+		if (message.ReferencedMessage != null)
+		{
+			message.ReferencedMessage.Discord = this;
+			this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
+			message.ReferencedMessage.PopulateMentions();
+		}
+
+		// Handling of user mentions
+		if (message.MentionedUsersInternal.Any())
+			foreach (var user in message.MentionedUsers)
+			{
+				user.Discord = this;
+				if (user.Id != message.Author.Id)
+					this.UserCache.AddOrUpdate(user.Id, user, (id, oldUsr) => oldUsr);
+			}
+
+		// This is fucking hacky
+		if (!message.MentionedChannelsInternal.Any() && message.Content != null && Utilities.ContainsChannelMentions(message.Content))
+		{
+			List<ChannelMention> mentions = new();
+			var channelMentions = Utilities.GetChannelMentions(message);
+			foreach(var mention in channelMentions)
+			{
+				var channel = this.InternalGetCachedChannel(mention) ?? this.InternalGetCachedThread(mention) ?? await this.ApiClient.GetChannelAsync(mention);
+				if (channel.Name == null)
+				{
+					mentions.Add(new ChannelMention()
+					{
+						Id = mention,
+						GuildId = null,
+						Name = null,
+						Discord = this,
+						Type = null
+					});
+					continue;
+				}
+				if (channel != null && channel.GuildId.HasValue)
+					mentions.Add(new ChannelMention()
+					{
+						Id = channel.Id,
+						GuildId = channel.GuildId,
+						Name = channel.Name,
+						Discord = this,
+						Type = channel.Type
+					});
+				else
+					mentions.Add(new ChannelMention()
+					{
+						Id = mention,
+						GuildId = null,
+						Name = null,
+						Discord = this,
+						Type = null
+					});
+			}
+			message.MentionedChannelsInternal.AddRange(mentions);
+		}
+		
+		message.PopulateMentions();
+
+		// embed cache is broken, component cache is broken
+
+		var ea = new MessageUpdateEventArgs(this.ServiceProvider)
+		{
+			Message = message,
+			MessageBefore = oldMessage,
+			MentionedUsers = message.MentionedUsers.ToList(),
+			MentionedRoles = message.MentionedRoles.ToList(),
+			MentionedChannels = message.MentionedChannels.ToList()
+		};
+		await this._messageUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
+	}
+	/*
 	/// <summary>
 	/// Handles the message update event.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The transport user (author).</param>
 	/// <param name="member">The transport member.</param>
 	/// <param name="referenceAuthor">The reference transport user (author).</param>
 	/// <param name="referenceMember">The reference transport member.</param>
 	internal async Task OnMessageUpdateEventAsync(DiscordMessage message, TransportUser author, TransportMember member, TransportUser referenceAuthor, TransportMember referenceMember)
 	{
 		DiscordGuild guild;
 
 		message.Discord = this;
 		var eventMessage = message;
 
 		DiscordMessage oldmsg = null;
 		if (this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
-			|| !this.MessageCache.TryGet(xm => xm.Id == eventMessage.Id && xm.ChannelId == eventMessage.ChannelId, out message))
+			|| !this.MessageCache.TryGetFirstOrDefault(xm => xm.Id == eventMessage.Id && xm.ChannelId == eventMessage.ChannelId, out message))
 		{
 			message = eventMessage;
 			this.PopulateMessageReactionsAndCache(message, author, member);
 			guild = message.Channel?.Guild;
 
 			if (message.ReferencedMessage != null)
 			{
 				message.ReferencedMessage.Discord = this;
 				this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
 				message.ReferencedMessage.PopulateMentions();
 			}
 		}
 		else
 		{
 			oldmsg = new DiscordMessage(message);
 
 			guild = message.Channel?.Guild;
 			message.EditedTimestampRaw = eventMessage.EditedTimestampRaw;
 			if (eventMessage.Content != null)
 				message.Content = eventMessage.Content;
 			message.Pinned = eventMessage.Pinned;
 			message.IsTts = eventMessage.IsTts;
 		}
-		message.EmbedsInternal.Clear();
-		message.EmbedsInternal.AddRange(eventMessage.EmbedsInternal);
-		message.ComponentsInternal.Clear();
-		message.ComponentsInternal.AddRange(eventMessage.ComponentsInternal);
-		message.MentionedUsersInternal.Clear();
-		message.MentionedUsersInternal.AddRange(eventMessage.MentionedUsersInternal ?? new());
-		message.MentionedRolesInternal.Clear();
-		message.MentionedRolesInternal.AddRange(eventMessage.MentionedRolesInternal ?? new());
-		message.MentionedChannelsInternal.Clear();
-		message.MentionedChannelsInternal.AddRange(eventMessage.MentionedChannelsInternal ?? new());
+
+		if (message.EmbedsInternal != null)
+		{
+			message.EmbedsInternal.Clear();
+			message.EmbedsInternal.AddRange(eventMessage.EmbedsInternal ?? new());
+		}
+		else
+			message.EmbedsInternal = new(eventMessage.EmbedsInternal ?? new());
+
+		if (message.ComponentsInternal != null)
+		{
+			message.ComponentsInternal.Clear();
+			message.ComponentsInternal.AddRange(eventMessage.ComponentsInternal ?? new());
+		}
+		else
+			message.ComponentsInternal = new(eventMessage.ComponentsInternal ?? new());
+
+		if (message.MentionedUsersInternal != null)
+		{
+			message.MentionedUsersInternal.Clear();
+			message.MentionedUsersInternal.AddRange(eventMessage.MentionedUsersInternal ?? new());
+		}
+		else
+			message.MentionedUsersInternal = new(eventMessage.MentionedUsersInternal ?? new());
+
+		if (message.MentionedRolesInternal != null)
+		{
+			message.MentionedRolesInternal.Clear();
+			message.MentionedRolesInternal.AddRange(eventMessage.MentionedRolesInternal ?? new());
+		}
+		else
+			message.MentionedRolesInternal = new(eventMessage.MentionedRolesInternal ?? new());
+
+		if (message.MentionedChannelsInternal != null)
+		{
+			message.MentionedChannelsInternal.Clear();
+			message.MentionedChannelsInternal.AddRange(eventMessage.MentionedChannelsInternal ?? new());
+		}
+		else
+			message.MentionedChannelsInternal = new(eventMessage.MentionedChannelsInternal ?? new());
+
 		message.MentionEveryone = eventMessage.MentionEveryone;
 
 		message.PopulateMentions();
 
 		var ea = new MessageUpdateEventArgs(this.ServiceProvider)
 		{
 			Message = message,
 			MessageBefore = oldmsg,
 			MentionedUsers = new ReadOnlyCollection<DiscordUser>(message.MentionedUsersInternal),
 			MentionedRoles = message.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(message.MentionedRolesInternal) : null,
 			MentionedChannels = message.MentionedChannelsInternal != null ? new ReadOnlyCollection<DiscordChannel>(message.MentionedChannelsInternal) : null
 		};
 		await this._messageUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
-
+	*/
 	/// <summary>
 	/// Handles the message delete event.
 	/// </summary>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal async Task OnMessageDeleteEventAsync(ulong messageId, ulong channelId, ulong? guildId)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
-			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
+			|| !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this,
 			};
 		}
 
 		if (this.Configuration.MessageCacheSize > 0)
 			this.MessageCache?.Remove(xm => xm.Id == msg.Id && xm.ChannelId == channelId);
 
 		var ea = new MessageDeleteEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Message = msg,
 			Guild = guild
 		};
 		await this._messageDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message bulk delete event.
 	/// </summary>
 	/// <param name="messageIds">The message ids.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal async Task OnMessageBulkDeleteEventAsync(ulong[] messageIds, ulong channelId, ulong? guildId)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		var msgs = new List<DiscordMessage>(messageIds.Length);
 		foreach (var messageId in messageIds)
 		{
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
-				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
+				|| !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this,
 				};
 			}
 			if (this.Configuration.MessageCacheSize > 0)
 				this.MessageCache?.Remove(xm => xm.Id == msg.Id && xm.ChannelId == channelId);
 			msgs.Add(msg);
 		}
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		var ea = new MessageBulkDeleteEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Messages = new ReadOnlyCollection<DiscordMessage>(msgs),
 			Guild = guild
 		};
 		await this._messagesBulkDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Message Reaction
 
 	/// <summary>
 	/// Handles the message reaction add event.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	/// <param name="mbr">The transport member.</param>
 	/// <param name="emoji">The emoji.</param>
 	internal async Task OnMessageReactionAddAsync(ulong userId, ulong messageId, ulong channelId, ulong? guildId, TransportMember mbr, DiscordEmoji emoji)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 		var guild = this.InternalGetCachedGuild(guildId);
 		emoji.Discord = this;
 
 		var usr = this.UpdateUser(new DiscordUser { Id = userId, Discord = this }, guildId, guild, mbr);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
-			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
+			|| !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this,
 				ReactionsInternal = new List<DiscordReaction>()
 			};
 		}
 
 		var react = msg.ReactionsInternal.FirstOrDefault(xr => xr.Emoji == emoji);
 		if (react == null)
 		{
 			msg.ReactionsInternal.Add(react = new DiscordReaction
 			{
 				Count = 1,
 				Emoji = emoji,
 				IsMe = this.CurrentUser.Id == userId
 			});
 		}
 		else
 		{
 			react.Count++;
 			react.IsMe |= this.CurrentUser.Id == userId;
 		}
 
 		var ea = new MessageReactionAddEventArgs(this.ServiceProvider)
 		{
 			Message = msg,
 			User = usr,
 			Guild = guild,
 			Emoji = emoji
 		};
 		await this._messageReactionAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message reaction remove event.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="emoji">The emoji.</param>
 	internal async Task OnMessageReactionRemoveAsync(ulong userId, ulong messageId, ulong channelId, ulong? guildId, DiscordEmoji emoji)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		emoji.Discord = this;
 
 		if (!this.UserCache.TryGetValue(userId, out var usr))
 			usr = new DiscordUser { Id = userId, Discord = this };
 
 		if (channel?.Guild != null)
 			usr = channel.Guild.Members.TryGetValue(userId, out var member)
 				? member
 				: new DiscordMember(usr) { Discord = this, GuildId = channel.GuildId.Value };
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
-			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
+			|| !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this
 			};
 		}
 
 		var react = msg.ReactionsInternal?.FirstOrDefault(xr => xr.Emoji == emoji);
 		if (react != null)
 		{
 			react.Count--;
 			react.IsMe &= this.CurrentUser.Id != userId;
 
 			if (msg.ReactionsInternal != null && react.Count <= 0) // shit happens
 				msg.ReactionsInternal.RemoveFirst(x => x.Emoji == emoji);
 		}
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		var ea = new MessageReactionRemoveEventArgs(this.ServiceProvider)
 		{
 			Message = msg,
 			User = usr,
 			Guild = guild,
 			Emoji = emoji
 		};
 		await this._messageReactionRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message reaction remove event.
 	/// Fired when all message reactions were removed.
 	/// </summary>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal async Task OnMessageReactionRemoveAllAsync(ulong messageId, ulong channelId, ulong? guildId)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
-			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
+			|| !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this
 			};
 		}
 
 		msg.ReactionsInternal?.Clear();
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		var ea = new MessageReactionsClearEventArgs(this.ServiceProvider)
 		{
 			Message = msg
 		};
 
 		await this._messageReactionsCleared.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message reaction remove event.
 	/// Fired when a emoji got removed.
 	/// </summary>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="dat">The raw discord emoji.</param>
 	internal async Task OnMessageReactionRemoveEmojiAsync(ulong messageId, ulong channelId, ulong guildId, JToken dat)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
-			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
+			|| !this.MessageCache.TryGetLastOrDefault(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this
 			};
 		}
 
 		var partialEmoji = dat.ToObject<DiscordEmoji>();
 
 		if (!guild.EmojisInternal.TryGetValue(partialEmoji.Id, out var emoji))
 		{
 			emoji = partialEmoji;
 			emoji.Discord = this;
 		}
 
 		msg.ReactionsInternal?.RemoveAll(r => r.Emoji.Equals(emoji));
 
 		var ea = new MessageReactionRemoveEmojiEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild,
 			Message = msg,
 			Emoji = emoji
 		};
 
 		await this._messageReactionRemovedEmoji.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Stage Instance
 
 	/// <summary>
 	/// Handles the stage instance create event.
 	/// </summary>
 	/// <param name="stage">The created stage instance.</param>
 	internal async Task OnStageInstanceCreateEventAsync(DiscordStageInstance stage)
 	{
 		stage.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(stage.GuildId);
 		guild.StageInstancesInternal[stage.Id] = stage;
 
 		await this._stageInstanceCreated.InvokeAsync(this, new StageInstanceCreateEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the stage instance update event.
 	/// </summary>
 	/// <param name="stage">The updated stage instance.</param>
 	internal async Task OnStageInstanceUpdateEventAsync(DiscordStageInstance stage)
 	{
 		stage.Discord = this;
 		var guild = this.InternalGetCachedGuild(stage.GuildId);
 		guild.StageInstancesInternal[stage.Id] = stage;
 
 		await this._stageInstanceUpdated.InvokeAsync(this, new StageInstanceUpdateEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the stage instance delete event.
 	/// </summary>
 	/// <param name="stage">The deleted stage instance.</param>
 	internal async Task OnStageInstanceDeleteEventAsync(DiscordStageInstance stage)
 	{
 		stage.Discord = this;
 		var guild = this.InternalGetCachedGuild(stage.GuildId);
 		guild.StageInstancesInternal[stage.Id] = stage;
 
 		await this._stageInstanceDeleted.InvokeAsync(this, new StageInstanceDeleteEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Thread
 
 	/// <summary>
 	/// Handles the thread create event.
 	/// </summary>
 	/// <param name="thread">The created thread.</param>
 	internal async Task OnThreadCreateEventAsync(DiscordThreadChannel thread)
 	{
 		thread.Discord = this;
 		this.InternalGetCachedGuild(thread.GuildId).ThreadsInternal.AddOrUpdate(thread.Id, thread, (oldThread, newThread) => newThread);
 
 		await this._threadCreated.InvokeAsync(this, new ThreadCreateEventArgs(this.ServiceProvider) { Thread = thread, Guild = thread.Guild, Parent = thread.Parent }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread update event.
 	/// </summary>
 	/// <param name="thread">The updated thread.</param>
 	internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
 	{
 		if (thread == null)
 			return;
 
 		thread.Discord = this;
 		var guild = thread.Guild;
 
 		var threadNew = this.InternalGetCachedThread(thread.Id);
 		DiscordThreadChannel threadOld = null;
 		ThreadUpdateEventArgs updateEvent;
 
 		if (threadNew != null)
 		{
 			threadOld = new DiscordThreadChannel
 			{
 				Discord = this,
 				Type = threadNew.Type,
 				ThreadMetadata = thread.ThreadMetadata,
 				ThreadMembersInternal = threadNew.ThreadMembersInternal,
 				ParentId = thread.ParentId,
 				OwnerId = thread.OwnerId,
 				Name = thread.Name,
 				LastMessageId = threadNew.LastMessageId,
 				MessageCount = thread.MessageCount,
 				MemberCount = thread.MemberCount,
 				GuildId = thread.GuildId,
 				LastPinTimestampRaw = threadNew.LastPinTimestampRaw,
 				PerUserRateLimit = threadNew.PerUserRateLimit,
 				CurrentMember = threadNew.CurrentMember
 			};
 
 			threadNew.ThreadMetadata = thread.ThreadMetadata;
 			threadNew.ParentId = thread.ParentId;
 			threadNew.OwnerId = thread.OwnerId;
 			threadNew.Name = thread.Name;
 			threadNew.LastMessageId = thread.LastMessageId.HasValue ? thread.LastMessageId : threadOld.LastMessageId;
 			threadNew.MessageCount = thread.MessageCount;
 			threadNew.MemberCount = thread.MemberCount;
 			threadNew.GuildId = thread.GuildId;
 
 			updateEvent = new ThreadUpdateEventArgs(this.ServiceProvider)
 			{
 				ThreadAfter = thread,
 				ThreadBefore = threadOld,
 				Guild = thread.Guild,
 				Parent = thread.Parent
 			};
 		}
 		else
 		{
 			updateEvent = new ThreadUpdateEventArgs(this.ServiceProvider)
 			{
 				ThreadAfter = thread,
 				Guild = thread.Guild,
 				Parent = thread.Parent
 			};
 			guild.ThreadsInternal[thread.Id] = thread;
 		}
 
 		await this._threadUpdated.InvokeAsync(this, updateEvent).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread delete event.
 	/// </summary>
 	/// <param name="thread">The deleted thread.</param>
 	internal async Task OnThreadDeleteEventAsync(DiscordThreadChannel thread)
 	{
 		if (thread == null)
 			return;
 
 		thread.Discord = this;
 
 		var gld = thread.Guild;
 		if (gld.ThreadsInternal.TryRemove(thread.Id, out var cachedThread))
 			thread = cachedThread;
 
 		await this._threadDeleted.InvokeAsync(this, new ThreadDeleteEventArgs(this.ServiceProvider) { Thread = thread, Guild = thread.Guild, Parent = thread.Parent, Type = thread.Type }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread list sync event.
 	/// </summary>
 	/// <param name="guild">The synced guild.</param>
 	/// <param name="channelIds">The synced channel ids.</param>
 	/// <param name="threads">The synced threads.</param>
 	/// <param name="members">The synced thread members.</param>
 	internal async Task OnThreadListSyncEventAsync(DiscordGuild guild, IReadOnlyList<ulong?> channelIds, IReadOnlyList<DiscordThreadChannel> threads, IReadOnlyList<DiscordThreadChannelMember> members)
 	{
 		guild.Discord = this;
 
 		var channels = channelIds.Select(x => guild.GetChannel(x.Value)); //getting channel objects
 		foreach (var chan in channels)
 		{
 			chan.Discord = this;
 		}
 		_ = threads.Select(x => x.Discord = this);
 
 		await this._threadListSynced.InvokeAsync(this, new ThreadListSyncEventArgs(this.ServiceProvider) { Guild = guild, Channels = channels.ToList().AsReadOnly(), Threads = threads, Members = members.ToList().AsReadOnly() }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread member update event.
 	/// </summary>
 	/// <param name="member">The updated member.</param>
 	internal async Task OnThreadMemberUpdateEventAsync(DiscordThreadChannelMember member)
 	{
 		member.Discord = this;
 		var thread = this.InternalGetCachedThread(member.Id);
 		if (thread == null)
 		{
 			var tempThread = await this.ApiClient.GetThreadAsync(member.Id);
 			thread = this.GuildsInternal[member.GuildId].ThreadsInternal.AddOrUpdate(member.Id, tempThread, (old, newThread) => newThread);
 		}
 
 		thread.CurrentMember = member;
 		thread.Guild.ThreadsInternal.AddOrUpdate(member.Id, thread, (oldThread, newThread) => newThread);
 
 
 		await this._threadMemberUpdated.InvokeAsync(this, new ThreadMemberUpdateEventArgs(this.ServiceProvider) { ThreadMember = member, Thread = thread }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread members update event.
 	/// </summary>
 	/// <param name="guild">The target guild.</param>
 	/// <param name="threadId">The thread id of the target thread this update belongs to.</param>
 	/// <param name="membersAdded">The added members.</param>
 	/// <param name="membersRemoved">The ids of the removed members.</param>
 	/// <param name="memberCount">The new member count.</param>
 	internal async Task OnThreadMembersUpdateEventAsync(DiscordGuild guild, ulong threadId, JArray membersAdded, JArray membersRemoved, int memberCount)
 	{
 		var thread = this.InternalGetCachedThread(threadId);
 		if (thread == null)
 		{
 			var tempThread = await this.ApiClient.GetThreadAsync(threadId);
 			thread = guild.ThreadsInternal.AddOrUpdate(threadId, tempThread, (old, newThread) => newThread);
 		}
 
 		thread.Discord = this;
 		guild.Discord = this;
 		List<DiscordThreadChannelMember> addedMembers = new();
 		List<ulong> removedMemberIds = new();
 
 		if (membersAdded != null)
 		{
 			foreach (var xj in membersAdded)
 			{
 				var xtm = xj.ToDiscordObject<DiscordThreadChannelMember>();
 				xtm.Discord = this;
 				xtm.GuildId = guild.Id;
 				if (xtm != null)
 					addedMembers.Add(xtm);
 
 				if (xtm.Id == this.CurrentUser.Id)
 					thread.CurrentMember = xtm;
 			}
 		}
 
 		var removedMembers = new List<DiscordMember>();
 		if (membersRemoved != null)
 		{
 			foreach (var removedId in membersRemoved)
 			{
 				removedMembers.Add(guild.MembersInternal.TryGetValue((ulong)removedId, out var member) ? member : new DiscordMember { Id = (ulong)removedId, GuildId = guild.Id, Discord = this });
 			}
 		}
 
 		if (removedMemberIds.Contains(this.CurrentUser.Id)) //indicates the bot was removed from the thread
 			thread.CurrentMember = null;
 
 		thread.MemberCount = memberCount;
 
 		var threadMembersUpdateArg = new ThreadMembersUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Thread = thread,
 			AddedMembers = addedMembers,
 			RemovedMembers = removedMembers,
 			MemberCount = memberCount
 		};
 
 		await this._threadMembersUpdated.InvokeAsync(this, threadMembersUpdateArg).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Activities
 	/// <summary>
 	/// Dispatches the <see cref="EmbeddedActivityUpdated"/> event.
 	/// </summary>
 	/// <param name="trActivity">The transport activity.</param>
 	/// <param name="guild">The guild.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="jUsers">The users in the activity.</param>
 	/// <param name="appId">The application id.</param>
 	internal async Task OnEmbeddedActivityUpdateAsync(JObject trActivity, DiscordGuild guild, ulong channelId, JArray jUsers, ulong appId)
 		=> await Task.Delay(20);
 
 	/*{
             try
             {
                 var users = j_users?.ToObject<List<ulong>>();
 
                 DiscordActivity old = null;
                 var uid = $"{guild.Id}_{channel_id}_{app_id}";
 
                 if (this._embeddedActivities.TryGetValue(uid, out var activity))
                 {
                     old = new DiscordActivity(activity);
                     DiscordJson.PopulateObject(tr_activity, activity);
                 }
                 else
                 {
                     activity = tr_activity.ToObject<DiscordActivity>();
                     this._embeddedActivities[uid] = activity;
                 }
 
                 var activity_users = new List<DiscordMember>();
 
                 var channel = this.InternalGetCachedChannel(channel_id) ?? await this.ApiClient.GetChannelAsync(channel_id);
 
                 if (users != null)
                 {
                     foreach (var user in users)
                     {
                         var activity_user = guild._members.TryGetValue(user, out var member) ? member : new DiscordMember { Id = user, _guild_id = guild.Id, Discord = this };
                         activity_users.Add(activity_user);
                     }
                 }
                 else
                     activity_users = null;
 
                 var ea = new EmbeddedActivityUpdateEventArgs(this.ServiceProvider)
                 {
                     Guild = guild,
                     Users = activity_users,
                     Channel = channel
 
                 };
                 await this._embeddedActivityUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
             } catch (Exception ex)
             {
                 this.Logger.LogError(ex, ex.Message);
             }
         }*/
 
 	#endregion
 
 	#region User/Presence Update
 
 	/// <summary>
 	/// Handles the presence update event.
 	/// </summary>
 	/// <param name="rawPresence">The raw presence.</param>
 	/// <param name="rawUser">The raw user.</param>
 
 	internal async Task OnPresenceUpdateEventAsync(JObject rawPresence, JObject rawUser)
 	{
 		var uid = (ulong)rawUser["id"];
 		DiscordPresence old = null;
 
 		if (this.PresencesInternal.TryGetValue(uid, out var presence))
 		{
 			old = new DiscordPresence(presence);
 			DiscordJson.PopulateObject(rawPresence, presence);
 		}
 		else
 		{
 			presence = rawPresence.ToObject<DiscordPresence>();
 			presence.Discord = this;
 			presence.Activity = new DiscordActivity(presence.RawActivity);
 			this.PresencesInternal[presence.InternalUser.Id] = presence;
 		}
 
 		// reuse arrays / avoid linq (this is a hot zone)
 		if (presence.Activities == null || rawPresence["activities"] == null)
 		{
 			presence.InternalActivities = Array.Empty<DiscordActivity>();
 		}
 		else
 		{
 			if (presence.InternalActivities.Length != presence.RawActivities.Length)
 				presence.InternalActivities = new DiscordActivity[presence.RawActivities.Length];
 
 			for (var i = 0; i < presence.InternalActivities.Length; i++)
 				presence.InternalActivities[i] = new DiscordActivity(presence.RawActivities[i]);
 
 			if (presence.InternalActivities.Length > 0)
 			{
 				presence.RawActivity = presence.RawActivities[0];
 
 				if (presence.Activity != null)
 					presence.Activity.UpdateWith(presence.RawActivity);
 				else
 					presence.Activity = new DiscordActivity(presence.RawActivity);
 			}
 		}
 
 		if (this.UserCache.TryGetValue(uid, out var usr))
 		{
 			if (old != null)
 			{
 				old.InternalUser.Username = usr.Username;
 				old.InternalUser.Discriminator = usr.Discriminator;
 				old.InternalUser.AvatarHash = usr.AvatarHash;
 			}
 
 			if (rawUser["username"] is object)
 				usr.Username = (string)rawUser["username"];
 			if (rawUser["discriminator"] is object)
 				usr.Discriminator = (string)rawUser["discriminator"];
 			if (rawUser["avatar"] is object)
 				usr.AvatarHash = (string)rawUser["avatar"];
 
 			presence.InternalUser.Username = usr.Username;
 			presence.InternalUser.Discriminator = usr.Discriminator;
 			presence.InternalUser.AvatarHash = usr.AvatarHash;
 		}
 
 		var usrafter = usr ?? new DiscordUser(presence.InternalUser);
 		var ea = new PresenceUpdateEventArgs(this.ServiceProvider)
 		{
 			Status = presence.Status,
 			Activity = presence.Activity,
 			User = usr,
 			PresenceBefore = old,
 			PresenceAfter = presence,
 			UserBefore = old != null ? new DiscordUser(old.InternalUser) : usrafter,
 			UserAfter = usrafter
 		};
 		await this._presenceUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the user settings update event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 
 	internal async Task OnUserSettingsUpdateEventAsync(TransportUser user)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 
 		var ea = new UserSettingsUpdateEventArgs(this.ServiceProvider)
 		{
 			User = usr
 		};
 		await this._userSettingsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the user update event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 
 	internal async Task OnUserUpdateEventAsync(TransportUser user)
 	{
 		var usrOld = new DiscordUser
 		{
 			AvatarHash = this.CurrentUser.AvatarHash,
 			Discord = this,
 			Discriminator = this.CurrentUser.Discriminator,
 			Email = this.CurrentUser.Email,
 			Id = this.CurrentUser.Id,
 			IsBot = this.CurrentUser.IsBot,
 			MfaEnabled = this.CurrentUser.MfaEnabled,
 			Username = this.CurrentUser.Username,
 			Verified = this.CurrentUser.Verified
 		};
 
 		this.CurrentUser.AvatarHash = user.AvatarHash;
 		this.CurrentUser.Discriminator = user.Discriminator;
 		this.CurrentUser.Email = user.Email;
 		this.CurrentUser.Id = user.Id;
 		this.CurrentUser.IsBot = user.IsBot;
 		this.CurrentUser.MfaEnabled = user.MfaEnabled;
 		this.CurrentUser.Username = user.Username;
 		this.CurrentUser.Verified = user.Verified;
 
 		var ea = new UserUpdateEventArgs(this.ServiceProvider)
 		{
 			UserAfter = this.CurrentUser,
 			UserBefore = usrOld
 		};
 		await this._userUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Voice
 
 	/// <summary>
 	/// Handles the voice state update event.
 	/// </summary>
 	/// <param name="raw">The raw voice state update object.</param>
 
 	internal async Task OnVoiceStateUpdateEventAsync(JObject raw)
 	{
 		var gid = (ulong)raw["guild_id"];
 		var uid = (ulong)raw["user_id"];
 		var gld = this.GuildsInternal[gid];
 
 		var vstateNew = raw.ToObject<DiscordVoiceState>();
 		vstateNew.Discord = this;
 
 		gld.VoiceStatesInternal.TryRemove(uid, out var vstateOld);
 
 		if (vstateNew.Channel != null)
 		{
 			gld.VoiceStatesInternal[vstateNew.UserId] = vstateNew;
 		}
 
 		if (gld.MembersInternal.TryGetValue(uid, out var mbr))
 		{
 			mbr.IsMuted = vstateNew.IsServerMuted;
 			mbr.IsDeafened = vstateNew.IsServerDeafened;
 		}
 		else
 		{
 			var transportMbr = vstateNew.TransportMember;
 			this.UpdateUser(new DiscordUser(transportMbr.User) { Discord = this }, gid, gld, transportMbr);
 		}
 
 		var ea = new VoiceStateUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = vstateNew.Guild,
 			Channel = vstateNew.Channel,
 			User = vstateNew.User,
 			SessionId = vstateNew.SessionId,
 
 			Before = vstateOld,
 			After = vstateNew
 		};
 		await this._voiceStateUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the voice server update event.
 	/// </summary>
 	/// <param name="endpoint">The new endpoint.</param>
 	/// <param name="token">The new token.</param>
 	/// <param name="guild">The guild.</param>
 
 	internal async Task OnVoiceServerUpdateEventAsync(string endpoint, string token, DiscordGuild guild)
 	{
 		var ea = new VoiceServerUpdateEventArgs(this.ServiceProvider)
 		{
 			Endpoint = endpoint,
 			VoiceToken = token,
 			Guild = guild
 		};
 		await this._voiceServerUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Commands
 
 	/// <summary>
 	/// Handles the application command create event.
 	/// </summary>
 	/// <param name="cmd">The application command.</param>
 	/// <param name="guildId">The optional guild id.</param>
 
 	internal async Task OnApplicationCommandCreateAsync(DiscordApplicationCommand cmd, ulong? guildId)
 	{
 		cmd.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null && guildId.HasValue)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId.Value,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Command = cmd
 		};
 
 		await this._applicationCommandCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the application command update event.
 	/// </summary>
 	/// <param name="cmd">The application command.</param>
 	/// <param name="guildId">The optional guild id.</param>
 
 	internal async Task OnApplicationCommandUpdateAsync(DiscordApplicationCommand cmd, ulong? guildId)
 	{
 		cmd.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null && guildId.HasValue)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId.Value,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Command = cmd
 		};
 
 		await this._applicationCommandUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the application command delete event.
 	/// </summary>
 	/// <param name="cmd">The application command.</param>
 	/// <param name="guildId">The optional guild id.</param>
 
 	internal async Task OnApplicationCommandDeleteAsync(DiscordApplicationCommand cmd, ulong? guildId)
 	{
 		cmd.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null && guildId.HasValue)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId.Value,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Command = cmd
 		};
 
 		await this._applicationCommandDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild application command counts update event.
 	/// </summary>
 	/// <param name="chatInputCommandCount">The <see cref="ApplicationCommandType.ChatInput"/> count.</param>
 	/// <param name="userContextMenuCommandCount">The <see cref="ApplicationCommandType.User"/> count.</param>
 	/// <param name="messageContextMenuCount">The <see cref="ApplicationCommandType.Message"/> count.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <returns>Count of application commands.</returns>
 	internal async Task OnGuildApplicationCommandCountsUpdateAsync(int chatInputCommandCount, int userContextMenuCommandCount, int messageContextMenuCount, ulong guildId)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId,
 				Discord = this
 			};
 		}
 
 		var ea = new GuildApplicationCommandCountEventArgs(this.ServiceProvider)
 		{
 			SlashCommands = chatInputCommandCount,
 			UserContextMenuCommands = userContextMenuCommandCount,
 			MessageContextMenuCommands = messageContextMenuCount,
 			Guild = guild
 		};
 
 		await this._guildApplicationCommandCountUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the application command permissions update event.
 	/// </summary>
 	/// <param name="perms">The new permissions.</param>
 	/// <param name="channelId">The command id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="applicationId">The application id.</param>
 	internal async Task OnApplicationCommandPermissionsUpdateAsync(IEnumerable<DiscordApplicationCommandPermission> perms, ulong channelId, ulong guildId, ulong applicationId)
 	{
 		if (applicationId != this.CurrentApplication.Id)
 			return;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		DiscordApplicationCommand cmd;
 		try
 		{
 			cmd = await this.GetGuildApplicationCommandAsync(guildId, channelId);
 		}
 		catch (NotFoundException)
 		{
 			cmd = await this.GetGlobalApplicationCommandAsync(channelId);
 		}
 
 		if (guild == null)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandPermissionsUpdateEventArgs(this.ServiceProvider)
 		{
 			Permissions = perms.ToList(),
 			Command = cmd,
 			ApplicationId = applicationId,
 			Guild = guild
 		};
 
 		await this._applicationCommandPermissionsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Interaction
 
 	/// <summary>
 	/// Handles the interaction create event.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="user">The transport user.</param>
 	/// <param name="member">The transport member.</param>
 	/// <param name="interaction">The interaction.</param>
 	internal async Task OnInteractionCreateAsync(ulong? guildId, ulong channelId, TransportUser user, TransportMember member, DiscordInteraction interaction)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 
 		interaction.ChannelId = channelId;
 		interaction.GuildId = guildId;
 		interaction.Discord = this;
 		interaction.Data.Discord = this;
 
 		if (member != null)
 		{
 			usr = new DiscordMember(member) { GuildId = guildId.Value, Discord = this };
 			this.UpdateUser(usr, guildId, interaction.Guild, member);
 		}
 		else
 		{
 			this.UserCache.AddOrUpdate(usr.Id, usr, (old, @new) => @new);
 		}
 
 		interaction.User = usr;
 
 		var resolved = interaction.Data.Resolved;
 		if (resolved != null)
 		{
 			if (resolved.Users != null)
 			{
 				foreach (var c in resolved.Users)
 				{
 					c.Value.Discord = this;
 					this.UserCache.AddOrUpdate(c.Value.Id, c.Value, (old, @new) => @new);
 				}
 			}
 
 			if (resolved.Members != null)
 			{
 				foreach (var c in resolved.Members)
 				{
 					c.Value.Discord = this;
 					c.Value.Id = c.Key;
 					c.Value.GuildId = guildId.Value;
 					c.Value.User.Discord = this;
 					this.UserCache.AddOrUpdate(c.Value.User.Id, c.Value.User, (old, @new) => @new);
 				}
 			}
 
 			if (resolved.Channels != null)
 			{
 				foreach (var c in resolved.Channels)
 				{
 					c.Value.Discord = this;
 
 					if (guildId.HasValue)
 						c.Value.GuildId = guildId.Value;
 				}
 			}
 
 			if (resolved.Roles != null)
 			{
 				foreach (var c in resolved.Roles)
 				{
 					c.Value.Discord = this;
 
 					if (guildId.HasValue)
 						c.Value.GuildId = guildId.Value;
 				}
 			}
 
 
 			if (resolved.Messages != null)
 			{
 				foreach (var m in resolved.Messages)
 				{
 					m.Value.Discord = this;
 
 					if (guildId.HasValue)
 						m.Value.GuildId = guildId.Value;
 				}
 			}
 
 
 			if (resolved.Attachments != null)
 				foreach (var a in resolved.Attachments)
 					a.Value.Discord = this;
 		}
 
 		if (interaction.Type is InteractionType.Component || interaction.Type is InteractionType.ModalSubmit)
 		{
 			if (interaction.Message != null)
 			{
 				interaction.Message.Discord = this;
 				interaction.Message.ChannelId = interaction.ChannelId;
 			}
 			var cea = new ComponentInteractionCreateEventArgs(this.ServiceProvider)
 			{
 				Message = interaction.Message,
 				Interaction = interaction
 			};
 
 			await this._componentInteractionCreated.InvokeAsync(this, cea).ConfigureAwait(false);
 		}
 		else
 		{
 			if (interaction.Data.Target.HasValue) // Context-Menu. //
 			{
 				var targetId = interaction.Data.Target.Value;
 				DiscordUser targetUser = null;
 				DiscordMember targetMember = null;
 				DiscordMessage targetMessage = null;
 
 				interaction.Data.Resolved.Messages?.TryGetValue(targetId, out targetMessage);
 				interaction.Data.Resolved.Members?.TryGetValue(targetId, out targetMember);
 				interaction.Data.Resolved.Users?.TryGetValue(targetId, out targetUser);
 
 				var ctea = new ContextMenuInteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Interaction = interaction,
 					TargetUser = targetMember ?? targetUser,
 					TargetMessage = targetMessage,
 					Type = interaction.Data.Type,
 				};
 				await this._contextMenuInteractionCreated.InvokeAsync(this, ctea).ConfigureAwait(false);
 			}
 			else
 			{
 				var ea = new InteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Interaction = interaction
 				};
 
 				await this._interactionCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 			}
 		}
 	}
 
 	#endregion
 
 	#region Misc
 
 	/// <summary>
 	/// Handles the typing start event.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="channel">The channel.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	/// <param name="started">The time when the user started typing.</param>
 	/// <param name="mbr">The transport member.</param>
 	internal async Task OnTypingStartEventAsync(ulong userId, ulong channelId, DiscordChannel channel, ulong? guildId, DateTimeOffset started, TransportMember mbr)
 	{
 		if (channel == null)
 		{
 			channel = new DiscordChannel
 			{
 				Discord = this,
 				Id = channelId,
 				GuildId = guildId ?? default,
 			};
 		}
 
 		var guild = this.InternalGetCachedGuild(guildId);
 		var usr = this.UpdateUser(new DiscordUser { Id = userId, Discord = this }, guildId, guild, mbr);
 
 		var ea = new TypingStartEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			User = usr,
 			Guild = guild,
 			StartedAt = started
 		};
 		await this._typingStarted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the webhooks update.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnWebhooksUpdateAsync(DiscordChannel channel, DiscordGuild guild)
 	{
 		var ea = new WebhooksUpdateEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild
 		};
 		await this._webhooksUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles all unknown events.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 	internal async Task OnUnknownEventAsync(GatewayPayload payload)
 	{
 		var ea = new UnknownEventArgs(this.ServiceProvider) { EventName = payload.EventName, Json = (payload.Data as JObject)?.ToString() };
 		await this._unknownEvent.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#endregion
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index e3c38e9f6..9a0830069 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1318 +1,1327 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord channel.
 /// </summary>
 public class DiscordChannel : SnowflakeObject, IEquatable<DiscordChannel>
 {
 	/// <summary>
 	/// Gets ID of the guild to which this channel belongs.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets ID of the category that contains this channel.
 	/// </summary>
 	[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Include)]
 	public ulong? ParentId { get; internal set; }
 
 	/// <summary>
 	/// Gets the category that contains this channel.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Parent
 		=> this.ParentId.HasValue ? this.Guild.GetChannel(this.ParentId.Value) : null;
 
 	/// <summary>
 	/// Gets the name of this channel.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of this channel.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public ChannelType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the template for new posts in this channel.
 	/// Applicable if forum channel.
 	/// </summary>
 	[JsonProperty("template", NullValueHandling = NullValueHandling.Ignore)]
 	public string Template { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's banner hash, when applicable.
 	/// </summary>
 	[JsonProperty("banner")]
 	public string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's banner in url form.
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.CHANNELS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
 	/// <summary>
 	/// Gets the position of this channel.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; internal set; }
 
 	/// <summary>
 	/// Gets the flags of this channel.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public ChannelFlags Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum available position to move the channel to.
 	/// This can contain outdated information.
 	/// </summary>
 	public int GetMaxPosition()
 	{
 		var channels = this.Guild.Channels.Values;
 		return this.ParentId != null
 			? this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).Last().Position
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).Last().Position
 					: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).Last().Position
 			: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).Last().Position;
 	}
 
 	/// <summary>
 	/// Gets the minimum available position to move the channel to.
 	/// </summary>
 	public int GetMinPosition()
 	{
 		var channels = this.Guild.Channels.Values;
 		return this.ParentId != null
 			? this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).First().Position
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).First().Position
 					: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).First().Position
 			: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).First().Position;
 	}
 
 	/// <summary>
 	/// Gets whether this channel is a DM channel.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsPrivate
 		=> this.Type == ChannelType.Private || this.Type == ChannelType.Group;
 
 	/// <summary>
 	/// Gets whether this channel is a channel category.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCategory
 		=> this.Type == ChannelType.Category;
 
 	/// <summary>
 	/// Gets whether this channel is a stage channel.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsStage
 		=> this.Type == ChannelType.Stage;
 
 	/// <summary>
 	/// Gets the guild to which this channel belongs.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.GuildId.HasValue && this.Discord.Guilds.TryGetValue(this.GuildId.Value, out var guild) ? guild : null;
 
 	/// <summary>
 	/// Gets a collection of permission overwrites for this channel.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordOverwrite> PermissionOverwrites
 		=> this._permissionOverwritesLazy.Value;
 
 	[JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordOverwrite> PermissionOverwritesInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordOverwrite>> _permissionOverwritesLazy;
 
 	/// <summary>
 	/// Gets the channel's topic. This is applicable to text channels only.
 	/// </summary>
 	[JsonProperty("topic", NullValueHandling = NullValueHandling.Ignore)]
 	public string Topic { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the last message sent in this channel. This is applicable to text channels only.
 	/// </summary>
 	[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? LastMessageId { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's bitrate. This is applicable to voice channels only.
 	/// </summary>
 	[JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Bitrate { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's user limit. This is applicable to voice channels only.
 	/// </summary>
 	[JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
 	public int? UserLimit { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the slow mode delay configured for this channel.</para>
 	/// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slow mode.</para>
 	/// </summary>
 	[JsonProperty("rate_limit_per_user")]
 	public int? PerUserRateLimit { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's video quality mode. This is applicable to voice channels only.
 	/// </summary>
 	[JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
 	public VideoQualityMode? QualityMode { get; internal set; }
 
 	/// <summary>
 	/// List of available tags for forum posts.
 	/// </summary>
 	[JsonProperty("available_tags", NullValueHandling = NullValueHandling.Ignore)]
 	public List<ForumPostTag> AvailableTags { get; internal set; }
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? LastPinTimestamp
 		=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned as raw string.
 	/// </summary>
 	[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string LastPinTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets this channel's default duration for newly created threads, in minutes, to automatically archive the thread after recent activity.
 	/// </summary>
 	[JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's mention string.
 	/// </summary>
 	[JsonIgnore]
 	public string Mention
 		=> Formatter.Mention(this);
 
 	/// <summary>
 	/// Gets this channel's children. This applies only to channel categories.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordChannel> Children =>
 		!this.IsCategory
 			? throw new ArgumentException("Only channel categories contain children.")
 			: this.Guild.ChannelsInternal.Values.Where(e => e.ParentId == this.Id).ToList();
 
 	/// <summary>
 	/// Gets the list of members currently in the channel (if voice channel), or members who can see the channel (otherwise).
 	/// </summary>
 	[JsonIgnore]
 	public virtual IReadOnlyList<DiscordMember> Users =>
 		this.Guild == null
 			? throw new InvalidOperationException("Cannot query users outside of guild channels.")
 			: this.IsVoiceJoinable()
 				? this.Guild.Members.Values.Where(x => x.VoiceState?.ChannelId == this.Id).ToList()
 				: this.Guild.Members.Values.Where(x => (this.PermissionsFor(x) & Permissions.AccessChannels) == Permissions.AccessChannels).ToList();
 
 	/// <summary>
 	/// Gets whether this channel is an NSFW channel.
 	/// </summary>
 	[JsonProperty("nsfw")]
 	public bool IsNsfw { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's region id (if voice channel).
 	/// </summary>
 	[JsonProperty("rtc_region", NullValueHandling = NullValueHandling.Ignore)]
 	internal string RtcRegionId { get; set; }
 
 	/// <summary>
 	/// Gets this channel's region override (if voice channel).
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceRegion RtcRegion
 		=> this.RtcRegionId != null ? this.Discord.VoiceRegions[this.RtcRegionId] : null;
 
 
 	/// <summary>
 	/// Only sent on the resolved channels of interaction responses for application commands.
 	/// Gets the permissions of the user in this channel who invoked the command.
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions? UserPermissions { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordChannel"/> class.
 	/// </summary>
 	internal DiscordChannel()
 	{
 		this._permissionOverwritesLazy = new Lazy<IReadOnlyList<DiscordOverwrite>>(() => new ReadOnlyCollection<DiscordOverwrite>(this.PermissionOverwritesInternal));
 	}
 
+	internal DiscordChannel(string name, ulong id, ulong? guildId, ChannelType? type) : this()
+	{
+		this.Name = name;
+		this.Id = id;
+		this.GuildId = guildId;
+		if (type != null)
+			this.Type = type.Value;
+	}
+
 	#region Methods
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(string content) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="builder">The builder with all the items to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="action">The builder with all the items to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 
 		return !this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 	}
 
 	/// <summary>
 	/// Deletes a guild channel
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteChannelAsync(this.Id, reason);
 
 	/// <summary>
 	/// Clones this channel. This operation will create a channel with identical settings to this one. Note that this will not copy messages.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>Newly-created channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> CloneAsync(string reason = null)
 	{
 		if (this.Guild == null)
 			throw new InvalidOperationException("Non-guild channels cannot be cloned.");
 
 		var ovrs = new List<DiscordOverwriteBuilder>();
 		foreach (var ovr in this.PermissionOverwritesInternal)
 			ovrs.Add(await new DiscordOverwriteBuilder().FromAsync(ovr).ConfigureAwait(false));
 
 		var bitrate = this.Bitrate;
 		var userLimit = this.UserLimit;
 		Optional<int?> perUserRateLimit = this.PerUserRateLimit;
 
 		if (!this.IsVoiceJoinable())
 		{
 			bitrate = null;
 			userLimit = null;
 		}
 
 		if (this.Type == ChannelType.Stage)
 		{
 			userLimit = null;
 		}
 		if (!this.IsWritable())
 		{
 			perUserRateLimit = Optional.None;
 		}
 
 		return await this.Guild.CreateChannelAsync(this.Name, this.Type, this.Parent, this.Topic, bitrate, userLimit, ovrs, this.IsNsfw, perUserRateLimit, this.QualityMode, this.DefaultAutoArchiveDuration, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Returns a specific message
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> GetMessageAsync(ulong id) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& this.Discord is DiscordClient dc
 		&& dc.MessageCache != null
-		&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
+		&& dc.MessageCache.TryGetLastOrDefault(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 			? msg
 			: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Modifies the current channel.
 	/// </summary>
 	/// <param name="action">Action to perform on this channel</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyAsync(Action<ChannelEditModel> action)
 	{
 		var mdl = new ChannelEditModel();
 		action(mdl);
 
 		if (mdl.DefaultAutoArchiveDuration.HasValue)
 		{
 			if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value))
 				throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 		}
 		if (mdl.Banner.HasValue)
 		{
 			if (!this.Guild.Features.CanSetChannelBanner)
 				throw new NotSupportedException($"Cannot modify Banner. Guild needs boost tier three.");
 		}
 
 		var bannerb64 = ImageTool.Base64FromStream(mdl.Banner);
 
 		return this.Discord.ApiClient.ModifyChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Nsfw,
 			mdl.Parent.Map(p => p?.Id), mdl.Bitrate, mdl.UserLimit, mdl.PerUserRateLimit, mdl.RtcRegion.Map(r => r?.Id),
 			mdl.QualityMode, mdl.DefaultAutoArchiveDuration, mdl.Type, mdl.PermissionOverwrites, bannerb64, mdl.AuditLogReason);
 	}
 
 	/// <summary>
 	/// Updates the channel position when it doesn't have a category.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionInCategoryAsync"/> for moving within a category.
 	/// </summary>
 	/// <param name="position">Position the channel should be moved to.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyPositionAsync(int position, string reason = null)
 	{
 		if (this.Guild == null)
 			throw new ArgumentException("Cannot modify order of non-guild channels.");
 		if (!this.IsMovable())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 		if (this.ParentId != null)
 			throw new ArgumentException("Cannot modify order of channels within a category. Use ModifyPositionInCategoryAsync instead.");
 
 		var pmds = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type).OrderBy(xc => xc.Position)
 			.Select(x => new RestGuildChannelReorderPayload
 			{
 				ChannelId = x.Id,
 				Position = x.Id == this.Id ? position : x.Position >= position ? x.Position + 1 : x.Position
 			});
 
 		return this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason);
 	}
 
 	/// <summary>
 	/// Updates the channel position within it's own category.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
 	/// </summary>
 	/// <param name="position">The position.</param>
 	/// <param name="reason">The reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel.</exception>
 	public async Task ModifyPositionInCategoryAsync(int position, string reason = null)
 	{
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 
 		var isUp = position > this.Position;
 
 		var channels = await this.InternalRefreshChannelsAsync();
 
 		var chns = this.ParentId != null
 			? this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
 					: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type)
 			: this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
 					: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type);
 
 		var ochns = chns.OrderBy(xc => xc.Position).ToArray();
 		var min = ochns.First().Position;
 		var max = ochns.Last().Position;
 
 		if (position > max || position < min)
 			throw new IndexOutOfRangeException($"Position is not in range. {position} is {(position > max ? "greater then the maximal" : "lower then the minimal")} position.");
 
 		var pmds = ochns.Select(x =>
 			new RestGuildChannelReorderPayload
 			{
 				ChannelId = x.Id,
 				Position = x.Id == this.Id
 					? position
 					: isUp
 						? x.Position <= position && x.Position > this.Position ? x.Position - 1 : x.Position
 						: x.Position >= position && x.Position < this.Position ? x.Position + 1 : x.Position
 			}
 		);
 
 		await this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Internally refreshes the channel list.
 	/// </summary>
 	private async Task<IReadOnlyList<DiscordChannel>> InternalRefreshChannelsAsync()
 	{
 		await this.RefreshPositionsAsync();
 		return this.Guild.Channels.Values.ToList().AsReadOnly();
 	}
 
 	/// <summary>
 	/// Refreshes the positions.
 	/// </summary>
 	public async Task RefreshPositionsAsync()
 	{
 		var channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Guild.Id);
 		this.Guild.ChannelsInternal.Clear();
 		foreach (var channel in channels.ToList())
 		{
 			channel.Discord = this.Discord;
 			foreach (var xo in channel.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = channel.Id;
 			}
 			this.Guild.ChannelsInternal[channel.Id] = channel;
 		}
 	}
 
 	/// <summary>
 	/// Updates the channel position within it's own category.
 	/// Valid modes: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
 	/// </summary>
 	/// <param name="mode">The mode. Valid: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up</param>
 	/// <param name="position">The position.</param>
 	/// <param name="reason">The reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel, a wrong mode is given or given position is zero.</exception>
 	public Task ModifyPositionInCategorySmartAsync(string mode, int position, string reason = null)
 	{
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 
 		if (mode != "+" && mode != "-" && mode != "down" && mode != "up")
 			throw new ArgumentException("Error with the selected mode: Valid is '+' or 'down' to move a channel down and '-' or 'up' to move a channel up");
 
 		var positive = mode == "+" || mode == "positive" || mode == "down";
 		var negative = mode == "-" || mode == "negative" || mode == "up";
 		return positive
 			? position < this.GetMaxPosition()
 				? this.ModifyPositionInCategoryAsync(this.Position + position, reason)
 				: throw new IndexOutOfRangeException($"Position is not in range of category.")
 			: negative
 				? position > this.GetMinPosition()
 					? this.ModifyPositionInCategoryAsync(this.Position - position, reason)
 					: throw new IndexOutOfRangeException($"Position is not in range of category.")
 				: throw new ArgumentException("You can only modify with +X or -X. 0 is not valid.");
 	}
 
 	/// <summary>
 	/// Updates the channel parent, moving the channel to the bottom of the new category.
 	/// </summary>
 	/// <param name="newParent">New parent for channel. Use <see cref="RemoveParentAsync(string)"/> to remove from parent.</param>
 	/// <param name="lockPermissions">Sync permissions with parent. Defaults to null.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyParentAsync(DiscordChannel newParent, bool? lockPermissions = null, string reason = null)
 	{
 		if (this.Guild == null)
 			throw new ArgumentException("Cannot modify parent of non-guild channels.");
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 		if (newParent.Type is not ChannelType.Category)
 			throw new ArgumentException("Only category type channels can be parents.");
 
 
 		var position = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type && xc.ParentId == newParent.Id) // gets list same type channels in parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
 		var pmds = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type)
 			.OrderBy(xc => xc.Position)
 			.Select(x =>
 			{
 				var pmd = new RestGuildChannelNewParentPayload
 				{
 					ChannelId = x.Id,
 					Position = x.Position >= position ? x.Position + 1 : x.Position,
 				};
 				if (x.Id == this.Id)
 				{
 					pmd.Position = position;
 					pmd.ParentId = newParent is not null ? newParent.Id : null;
 					pmd.LockPermissions = lockPermissions;
 				}
 
 				return pmd;
 			});
 
 		return this.Discord.ApiClient.ModifyGuildChannelParentAsync(this.Guild.Id, pmds, reason);
 	}
 
 	/// <summary>
 	/// Moves the channel out of a category.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveParentAsync(string reason = null)
 	{
 		if (this.Guild == null)
 			throw new ArgumentException("Cannot modify parent of non-guild channels.");
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 
 		var pmds = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type)
 			.OrderBy(xc => xc.Position)
 			.Select(x =>
 			{
 				var pmd = new RestGuildChannelNoParentPayload { ChannelId = x.Id };
 				if (x.Id == this.Id)
 				{
 					pmd.Position = 1;
 					pmd.ParentId = null;
 				}
 				else
 				{
 					pmd.Position = x.Position < this.Position ? x.Position + 1 : x.Position;
 				}
 
 				return pmd;
 			});
 
 		return this.Discord.ApiClient.DetachGuildChannelParentAsync(this.Guild.Id, pmds, reason);
 	}
 
 	/// <summary>
 	/// Returns a list of messages before a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="before">Message to fetch before from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, before, null, null);
 
 	/// <summary>
 	/// Returns a list of messages after a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="after">Message to fetch after from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, after, null);
 
 	/// <summary>
 	/// Returns a list of messages around a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="around">Message to fetch around from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, null, around);
 
 	/// <summary>
 	/// Returns a list of messages from the last message in the channel.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
 		this.GetMessagesInternalAsync(limit, null, null, null);
 
 	/// <summary>
 	/// Returns a list of messages
 	/// </summary>
 	/// <param name="limit">How many messages should be returned.</param>
 	/// <param name="before">Get messages before snowflake.</param>
 	/// <param name="after">Get messages after snowflake.</param>
 	/// <param name="around">Get messages around snowflake.</param>
 	private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
 	{
 		if (!this.IsWritable())
 			throw new ArgumentException("Cannot get the messages of a non-text channel.");
 
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of messages.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordMessage>();
 
 		//return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
 		if (limit > 100 && around != null)
 			throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
 		var msgs = new List<DiscordMessage>(limit);
 		var remaining = limit;
 		ulong? last = null;
 		var isAfter = after != null;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			if (!isAfter)
 			{
 				msgs.AddRange(fetch);
 				last = fetch.LastOrDefault()?.Id;
 			}
 			else
 			{
 				msgs.InsertRange(0, fetch);
 				last = fetch.FirstOrDefault()?.Id;
 			}
 		}
 		while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordMessage>(msgs);
 	}
 
 	/// <summary>
 	/// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
 	/// </summary>
 	/// <param name="messages">A collection of messages to delete.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
 	{
 		// don't enumerate more than once
 		var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
 		if (messages == null || !msgs.Any())
 			throw new ArgumentException("You need to specify at least one message to delete.");
 
 		if (msgs.Length < 2)
 		{
 			await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
 			return;
 		}
 
 		for (var i = 0; i < msgs.Length; i += 100)
 			await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a message
 	/// </summary>
 	/// <param name="message">The message to be deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteMessageAsync(DiscordMessage message, string reason = null)
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 	/// <summary>
 	/// Returns a list of invite objects
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync() =>
 		this.Guild == null
 			? throw new ArgumentException("Cannot get the invites of a channel that does not belong to a guild.")
 			: this.Discord.ApiClient.GetChannelInvitesAsync(this.Id);
 
 	/// <summary>
 	/// Create a new invite object
 	/// </summary>
 	/// <param name="maxAge">Duration of invite in seconds before expiry, or 0 for never.  Defaults to 86400.</param>
 	/// <param name="maxUses">Max number of uses or 0 for unlimited. Defaults to 0</param>
 	/// <param name="temporary">Whether this invite should be temporary. Defaults to false.</param>
 	/// <param name="unique">Whether this invite should be unique. Defaults to false.</param>
 	/// <param name="targetType">The target type. Defaults to null.</param>
 	/// <param name="targetApplication">The target activity. Defaults to null.</param>
 	/// <param name="targetUser">The target user id. Defaults to null.</param>
 	/// <param name="reason">The audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> CreateInviteAsync(int maxAge = 86400, int maxUses = 0, bool temporary = false, bool unique = false, TargetType? targetType = null, TargetActivity? targetApplication = null, ulong? targetUser = null, string reason = null)
 		=> this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, maxAge, maxUses, targetType, targetApplication, targetUser, temporary, unique, reason);
 
 	#region Stage
 
 	/// <summary>
 	/// Opens a stage.
 	/// </summary>
 	/// <param name="topic">Topic of the stage.</param>
 	/// <param name="sendStartNotification">Whether @everyone should be notified.</param>
 	/// <param name="privacyLevel">Privacy level of the stage (Defaults to <see cref="StagePrivacyLevel.GuildOnly"/>.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <returns>Stage instance</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordStageInstance> OpenStageAsync(string topic, bool sendStartNotification = false, StagePrivacyLevel privacyLevel = StagePrivacyLevel.GuildOnly, string reason = null)
 		=> await this.Discord.ApiClient.CreateStageInstanceAsync(this.Id, topic, sendStartNotification, privacyLevel, reason);
 
 	/// <summary>
 	/// Modifies a stage topic.
 	/// </summary>
 	/// <param name="topic">New topic of the stage.</param>
 	/// <param name="privacyLevel">New privacy level of the stage.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task ModifyStageAsync(Optional<string> topic, Optional<StagePrivacyLevel> privacyLevel, string reason = null)
 		=> await this.Discord.ApiClient.ModifyStageInstanceAsync(this.Id, topic, privacyLevel, reason);
 
 	/// <summary>
 	/// Closes a stage.
 	/// </summary>
 	/// <param name="reason">Audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task CloseStageAsync(string reason = null)
 		=> await this.Discord.ApiClient.DeleteStageInstanceAsync(this.Id, reason);
 
 	/// <summary>
 	/// Gets a stage.
 	/// </summary>
 	/// <returns>The requested stage.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or <see cref="Permissions.UseVoice"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordStageInstance> GetStageAsync()
 		=> await this.Discord.ApiClient.GetStageInstanceAsync(this.Id);
 
 	#endregion
 
 	#region Scheduled Events
 
 	/// <summary>
 	/// Creates a scheduled event based on the channel type.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="scheduledStartTime">The scheduled start time.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="coverImage">The cover image.</param>
 	/// <param name="reason">The reason.</param>
 	/// <returns>A scheduled event.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the resource does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, string description = null, Optional<Stream> coverImage = default, string reason = null)
 	{
 		if (!this.IsVoiceJoinable())
 			throw new NotSupportedException("Cannot create a scheduled event for this type of channel. Channel type must be either voice or stage.");
 
 		var type = this.Type == ChannelType.Voice ? ScheduledEventEntityType.Voice : ScheduledEventEntityType.StageInstance;
 
 		return await this.Guild.CreateScheduledEventAsync(name, scheduledStartTime, null, this, null, description, type, coverImage, reason);
 	}
 
 	#endregion
 
 	#region Threads
 
 	/// <summary>
 	/// Creates a thread.
 	/// Depending on whether it is created inside an <see cref="ChannelType.News"/> or an <see cref="ChannelType.Text"/> it is either an <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.
 	/// Depending on whether the <see cref="ChannelType"/> is set to <see cref="ChannelType.PrivateThread"/> it is either an <see cref="ChannelType.PrivateThread"/> or an <see cref="ChannelType.PublicThread"/> (default).
 	/// </summary>
 	/// <param name="name">The name of the thread.</param>
 	/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/>.</param>
 	/// <param name="type">Can be either an <see cref="ChannelType.PrivateThread"/>, <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.</param>
 	/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <returns>The created thread.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePublicThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> or if creating a private thread the <see cref="Permissions.CreatePrivateThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>. Or if <see cref="GuildFeatures.CanCreatePrivateThreads"/> is not enabled for guild. This happens, if the guild does not have <see cref="PremiumTier.TierTwo"/></exception>
 	public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null) =>
 		type != ChannelType.NewsThread && type != ChannelType.PublicThread && type != ChannelType.PrivateThread
 			? throw new NotSupportedException("Wrong thread type given.")
 			: !this.IsThreadHolder()
 				? throw new NotSupportedException("Parent channel can't have threads.")
 				: type == ChannelType.PrivateThread
 					? Utilities.CheckThreadPrivateFeature(this.Guild)
 						? Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
 							? await this.Discord.ApiClient.CreateThreadAsync(this.Id, null, name, autoArchiveDuration, type, rateLimitPerUser, reason)
 							: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.")
 						: throw new NotSupportedException($"Cannot create a private thread. Guild needs to be boost tier two.")
 					: Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
 						? await this.Discord.ApiClient.CreateThreadAsync(this.Id, null, name, autoArchiveDuration, this.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, reason)
 						: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 	/// <summary>
 	/// Gets joined archived private threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <param name="before">Get threads created before this thread id.</param>
 	/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetJoinedPrivateArchivedThreadsAsync(this.Id, before, limit);
 
 	/// <summary>
 	/// Gets archived public threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <param name="before">Get threads created before this thread id.</param>
 	/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetPublicArchivedThreadsAsync(this.Id, before, limit);
 
 	/// <summary>
 	/// Gets archived private threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <param name="before">Get threads created before this thread id.</param>
 	/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> or <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetPrivateArchivedThreadsAsync(this.Id, before, limit);
 
 	#endregion
 
 	/// <summary>
 	/// Adds a channel permission overwrite for specified role.
 	/// </summary>
 	/// <param name="role">The role to have the permission added.</param>
 	/// <param name="allow">The permissions to allow.</param>
 	/// <param name="deny">The permissions to deny.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddOverwriteAsync(DiscordRole role, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
 		=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, role.Id, allow, deny, "role", reason);
 
 
 	/// <summary>
 	/// Adds a channel permission overwrite for specified member.
 	/// </summary>
 	/// <param name="member">The member to have the permission added.</param>
 	/// <param name="allow">The permissions to allow.</param>
 	/// <param name="deny">The permissions to deny.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddOverwriteAsync(DiscordMember member, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
 		=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, member.Id, allow, deny, "member", reason);
 
 	/// <summary>
 	/// Deletes a channel permission overwrite for specified member.
 	/// </summary>
 	/// <param name="member">The member to have the permission deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOverwriteAsync(DiscordMember member, string reason = null)
 		=> this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, member.Id, reason);
 
 	/// <summary>
 	/// Deletes a channel permission overwrite for specified role.
 	/// </summary>
 	/// <param name="role">The role to have the permission deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOverwriteAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Post a typing indicator.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TriggerTypingAsync() =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot start typing in a non-text channel.")
 			: this.Discord.ApiClient.TriggerTypingAsync(this.Id);
 
 	/// <summary>
 	/// Returns all pinned messages.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync() =>
 		!this.IsWritable()
 			? throw new ArgumentException("A non-text channel does not have pinned messages.")
 			: this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
 
 	/// <summary>
 	/// Create a new webhook.
 	/// </summary>
 	/// <param name="name">The name of the webhook.</param>
 	/// <param name="avatar">The image for the default webhook avatar.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordWebhook> CreateWebhookAsync(string name, Optional<Stream> avatar = default, string reason = null)
 	{
 		var av64 = ImageTool.Base64FromStream(avatar);
 		return await this.Discord.ApiClient.CreateWebhookAsync(this.Id, name, av64, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Returns a list of webhooks.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 		=> this.Discord.ApiClient.GetChannelWebhooksAsync(this.Id);
 
 	/// <summary>
 	/// Moves a member to this voice channel.
 	/// </summary>
 	/// <param name="member">The member to be moved.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exists or if the Member does not exists.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task PlaceMemberAsync(DiscordMember member)
 	{
 		if (!this.IsVoiceJoinable())
 			throw new ArgumentException("Cannot place a member in a non-voice channel.");
 
 		await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, member.Id, default, default, default,
 			default, this.Id, null).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Follows a news channel.
 	/// </summary>
 	/// <param name="targetChannel">Channel to crosspost messages to.</param>
 	/// <exception cref="System.ArgumentException">Thrown when trying to follow a non-news channel.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> on the target channel.</exception>
 	public Task<DiscordFollowedChannel> FollowAsync(DiscordChannel targetChannel) =>
 		this.Type != ChannelType.News
 			? throw new ArgumentException("Cannot follow a non-news channel.")
 			: this.Discord.ApiClient.FollowChannelAsync(this.Id, targetChannel.Id);
 
 	/// <summary>
 	/// Publishes a message in a news channel to following channels.
 	/// </summary>
 	/// <param name="message">Message to publish.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the message has already been crossposted.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">
 	///     Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> and/or <see cref="Permissions.SendMessages"/>
 	/// </exception>
 	public Task<DiscordMessage> CrosspostMessageAsync(DiscordMessage message) =>
 		(message.Flags & MessageFlags.Crossposted) == MessageFlags.Crossposted
 			? throw new ArgumentException("Message is already crossposted.")
 			: this.Discord.ApiClient.CrosspostMessageAsync(this.Id, message.Id);
 
 	/// <summary>
 	/// Updates the current user's suppress state in this channel, if stage channel.
 	/// </summary>
 	/// <param name="suppress">Toggles the suppress state.</param>
 	/// <param name="requestToSpeakTimestamp">Sets the time the user requested to speak.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the channel is not a stage channel.</exception>
 	public async Task UpdateCurrentUserVoiceStateAsync(bool? suppress, DateTimeOffset? requestToSpeakTimestamp = null)
 	{
 		if (this.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
 		await this.Discord.ApiClient.UpdateCurrentUserVoiceStateAsync(this.GuildId.Value, this.Id, suppress, requestToSpeakTimestamp).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Calculates permissions for a given member.
 	/// </summary>
 	/// <param name="mbr">Member to calculate permissions for.</param>
 	/// <returns>Calculated permissions for a given member.</returns>
 	public Permissions PermissionsFor(DiscordMember mbr)
 	{
 		// user > role > everyone
 		// allow > deny > undefined
 		// =>
 		// user allow > user deny > role allow > role deny > everyone allow > everyone deny
 
 		if (this.IsPrivate || this.Guild == null)
 			return Permissions.None;
 
 		if (this.Guild.OwnerId == mbr.Id)
 			return PermissionMethods.FullPerms;
 
 		Permissions perms;
 
 		// assign @everyone permissions
 		var everyoneRole = this.Guild.EveryoneRole;
 		perms = everyoneRole.Permissions;
 
 		// roles that member is in
 		var mbRoles = mbr.Roles.Where(xr => xr.Id != everyoneRole.Id);
 
 		// assign permissions from member's roles (in order)
 		perms |= mbRoles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
 		// Administrator grants all permissions and cannot be overridden
 		if ((perms & Permissions.Administrator) == Permissions.Administrator)
 			return PermissionMethods.FullPerms;
 
 		// channel overrides for roles that member is in
 		var mbRoleOverrides = mbRoles
 			.Select(xr => this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == xr.Id))
 			.Where(xo => xo != null)
 			.ToList();
 
 		// assign channel permission overwrites for @everyone pseudo-role
 		var everyoneOverwrites = this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == everyoneRole.Id);
 		if (everyoneOverwrites != null)
 		{
 			perms &= ~everyoneOverwrites.Denied;
 			perms |= everyoneOverwrites.Allowed;
 		}
 
 		// assign channel permission overwrites for member's roles (explicit deny)
 		perms &= ~mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Denied);
 		// assign channel permission overwrites for member's roles (explicit allow)
 		perms |= mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Allowed);
 
 		// channel overrides for just this member
 		var mbOverrides = this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == mbr.Id);
 		if (mbOverrides == null) return perms;
 
 		// assign channel permission overwrites for just this member
 		perms &= ~mbOverrides.Denied;
 		perms |= mbOverrides.Allowed;
 
 		return perms;
 	}
 
 	/// <summary>
 	/// Returns a string representation of this channel.
 	/// </summary>
 	/// <returns>String representation of this channel.</returns>
 	public override string ToString() =>
 		this.Type == ChannelType.Category
 			? $"Channel Category {this.Name} ({this.Id})"
 			: this.Type == ChannelType.Text || this.Type == ChannelType.News || this.IsThread()
 				? $"Channel #{this.Name} ({this.Id})"
 				: this.IsVoiceJoinable()
 					? $"Channel #!{this.Name} ({this.Id})"
 					: !string.IsNullOrWhiteSpace(this.Name) ? $"Channel {this.Name} ({this.Id})" : $"Channel {this.Id}";
 
 	#endregion
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordChannel"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordChannel"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordChannel);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordChannel"/> is equal to another <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordChannel"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordChannel"/> is equal to this <see cref="DiscordChannel"/>.</returns>
 	public bool Equals(DiscordChannel e)
 		=> e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordChannel"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordChannel"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are equal.</returns>
 	public static bool operator ==(DiscordChannel e1, DiscordChannel e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordChannel"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are not equal.</returns>
 	public static bool operator !=(DiscordChannel e1, DiscordChannel e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
index d0e8a7d3c..39c6108f7 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
@@ -1,1306 +1,1306 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities;
 
 public partial class DiscordGuild
 {
 	// TODO: Rework audit logs!
 	/// <summary>
 	/// Gets audit log entries for this guild.
 	/// </summary>
 	/// <param name="limit">Maximum number of entries to fetch.</param>
 	/// <param name="byMember">Filter by member responsible.</param>
 	/// <param name="actionType">Filter by action type.</param>
 	/// <returns>A collection of requested audit log entries.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember byMember = null, AuditLogActionType? actionType = null)
 	{
 		var alrs = new List<AuditLog>();
 		int ac = 1, tc = 0, rmn = 100;
 		var last = 0ul;
 		while (ac > 0)
 		{
 			rmn = limit != null ? limit.Value - tc : 100;
 			rmn = Math.Min(100, rmn);
 			if (rmn <= 0) break;
 
 			var alr = await this.Discord.ApiClient.GetAuditLogsAsync(this.Id, rmn, null, last == 0 ? null : (ulong?)last, byMember?.Id, (int?)actionType).ConfigureAwait(false);
 			ac = alr.Entries.Count();
 			tc += ac;
 			if (ac > 0)
 			{
 				last = alr.Entries.Last().Id;
 				alrs.Add(alr);
 			}
 		}
 
 		var amr = alrs.SelectMany(xa => xa.Users)
 			.GroupBy(xu => xu.Id)
 			.Select(xgu => xgu.First());
 
 		foreach (var xau in amr)
 		{
 			if (this.Discord.UserCache.ContainsKey(xau.Id))
 				continue;
 
 			var xtu = new TransportUser
 			{
 				Id = xau.Id,
 				Username = xau.Username,
 				Discriminator = xau.Discriminator,
 				AvatarHash = xau.AvatarHash
 			};
 			var xu = new DiscordUser(xtu) { Discord = this.Discord };
 			xu = this.Discord.UserCache.AddOrUpdate(xu.Id, xu, (id, old) =>
 			{
 				old.Username = xu.Username;
 				old.Discriminator = xu.Discriminator;
 				old.AvatarHash = xu.AvatarHash;
 				return old;
 			});
 		}
 
 		var atgse = alrs.SelectMany(xa => xa.ScheduledEvents)
 			.GroupBy(xse => xse.Id)
 			.Select(xgse => xgse.First());
 
 		var ath = alrs.SelectMany(xa => xa.Threads)
 			.GroupBy(xt => xt.Id)
 			.Select(xgt => xgt.First());
 
 		var aig = alrs.SelectMany(xa => xa.Integrations)
 			.GroupBy(xi => xi.Id)
 			.Select(xgi => xgi.First());
 
 		var ahr = alrs.SelectMany(xa => xa.Webhooks)
 			.GroupBy(xh => xh.Id)
 			.Select(xgh => xgh.First());
 
 		var ams = amr.Select(xau => this.MembersInternal != null && this.MembersInternal.TryGetValue(xau.Id, out var member) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, GuildId = this.Id });
 		var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
 #pragma warning disable CS0219
 		Dictionary<ulong, DiscordThreadChannel> dtc = null;
 		Dictionary<ulong, DiscordIntegration> di = null;
 		Dictionary<ulong, DiscordScheduledEvent> dse = null;
 #pragma warning restore
 
 		Dictionary<ulong, DiscordWebhook> ahd = null;
 		if (ahr.Any())
 		{
 			var whr = await this.GetWebhooksAsync().ConfigureAwait(false);
 			var whs = whr.ToDictionary(xh => xh.Id, xh => xh);
 
 			var amh = ahr.Select(xah => whs.TryGetValue(xah.Id, out var webhook) ? webhook : new DiscordWebhook { Discord = this.Discord, Name = xah.Name, Id = xah.Id, AvatarHash = xah.AvatarHash, ChannelId = xah.ChannelId, GuildId = xah.GuildId, Token = xah.Token });
 			ahd = amh.ToDictionary(xh => xh.Id, xh => xh);
 		}
 
 		var acs = alrs.SelectMany(xa => xa.Entries).OrderByDescending(xa => xa.Id);
 		var entries = new List<DiscordAuditLogEntry>();
 		foreach (var xac in acs)
 		{
 			DiscordAuditLogEntry entry = null;
 			ulong t1, t2;
 			int t3, t4;
 			long t5, t6;
 			bool p1, p2;
 			switch (xac.ActionType)
 			{
 				case AuditLogActionType.Invalid:
 					break;
 
 				case AuditLogActionType.GuildUpdate:
 					entry = new DiscordAuditLogGuildEntry
 					{
 						Target = this
 					};
 
 					var entrygld = entry as DiscordAuditLogGuildEntry;
 					foreach (var xc in xac.Changes)
 					{
 						PropertyChange<DiscordChannel> GetChannelChange()
 						{
 							ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 							ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 							return new PropertyChange<DiscordChannel>
 							{
 								Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 							};
 						}
 
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrygld.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "owner_id":
 								entrygld.OwnerChange = new PropertyChange<DiscordMember>
 								{
 									Before = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.OldValueUlong, out var oldMember) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
 									After = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.NewValueUlong, out var newMember) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
 								};
 								break;
 
 							case "icon_hash":
 								entrygld.IconChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.OldValueString}.webp" : null,
 									After = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.NewValueString}.webp" : null
 								};
 								break;
 
 							case "verification_level":
 								entrygld.VerificationLevelChange = new PropertyChange<VerificationLevel>
 								{
 									Before = (VerificationLevel)(long)xc.OldValue,
 									After = (VerificationLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "afk_channel_id":
 								entrygld.AfkChannelChange = GetChannelChange();
 								break;
 
 							case "system_channel_flags":
 								entrygld.SystemChannelFlagsChange = new PropertyChange<SystemChannelFlags>()
 								{
 									Before = (SystemChannelFlags)(long)xc.OldValue,
 									After = (SystemChannelFlags)(long)xc.NewValue
 								};
 								break;
 
 							case "widget_channel_id":
 								entrygld.WidgetChannelChange = GetChannelChange();
 								break;
 
 							case "rules_channel_id":
 								entrygld.RulesChannelChange = GetChannelChange();
 								break;
 
 							case "public_updates_channel_id":
 								entrygld.PublicUpdatesChannelChange = GetChannelChange();
 								break;
 
 							case "splash_hash":
 								entrygld.SplashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.OldValueString}.webp?size=2048" : null,
 									After = xc.NewValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.NewValueString}.webp?size=2048" : null
 								};
 								break;
 
 							case "default_message_notifications":
 								entrygld.NotificationSettingsChange = new PropertyChange<DefaultMessageNotifications>
 								{
 									Before = (DefaultMessageNotifications)(long)xc.OldValue,
 									After = (DefaultMessageNotifications)(long)xc.NewValue
 								};
 								break;
 
 							case "system_channel_id":
 								entrygld.SystemChannelChange = GetChannelChange();
 								break;
 
 							case "explicit_content_filter":
 								entrygld.ExplicitContentFilterChange = new PropertyChange<ExplicitContentFilter>
 								{
 									Before = (ExplicitContentFilter)(long)xc.OldValue,
 									After = (ExplicitContentFilter)(long)xc.NewValue
 								};
 								break;
 
 							case "mfa_level":
 								entrygld.MfaLevelChange = new PropertyChange<MfaLevel>
 								{
 									Before = (MfaLevel)(long)xc.OldValue,
 									After = (MfaLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "region":
 								entrygld.RegionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "vanity_url_code":
 								entrygld.VanityUrlCodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "premium_progress_bar_enabled":
 								entrygld.PremiumProgressBarChange = new PropertyChange<bool>
 								{
 									Before = (bool)xc.OldValue,
 									After = (bool)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ChannelCreate:
 				case AuditLogActionType.ChannelDelete:
 				case AuditLogActionType.ChannelUpdate:
 					entry = new DiscordAuditLogChannelEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value) ?? new DiscordChannel { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrychn = entry as DiscordAuditLogChannelEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrychn.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrychn.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "flags":
 								entrychn.ChannelFlagsChange = new PropertyChange<ChannelFlags>()
 								{
 									Before = (ChannelFlags)(long)(xc.OldValue ?? 0L),
 									After = (ChannelFlags)(long)(xc.NewValue ?? 0L)
 								};
 								break;
 
 							case "permission_overwrites":
 								var olds = xc.OldValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								var news = xc.NewValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								entrychn.OverwriteChange = new PropertyChange<IReadOnlyList<DiscordOverwrite>>
 								{
 									Before = olds != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(olds)) : null,
 									After = news != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(news)) : null
 								};
 								break;
 
 							case "topic":
 								entrychn.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "nsfw":
 								entrychn.NsfwChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "rtc_region":
 								entrychn.RtcRegionIdChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "bitrate":
 								entrychn.BitrateChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "user_limit":
 								entrychn.UserLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrychn.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "default_auto_archive_duration":
 								entrychn.DefaultAutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = (ThreadAutoArchiveDuration?)(long?)xc.OldValue,
 									After = (ThreadAutoArchiveDuration?)(long?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.OverwriteCreate:
 				case AuditLogActionType.OverwriteDelete:
 				case AuditLogActionType.OverwriteUpdate:
 					entry = new DiscordAuditLogOverwriteEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value)?.PermissionOverwrites.FirstOrDefault(xo => xo.Id == xac.Options.Id),
 						Channel = this.GetChannel(xac.TargetId.Value)
 					};
 
 					var entryovr = entry as DiscordAuditLogOverwriteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "deny":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.DenyChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "allow":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.AllowChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "type":
 								entryovr.TypeChange = new PropertyChange<OverwriteType?>
 								{
 									Before = xc.OldValue != null ? (OverwriteType)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (OverwriteType)(long)xc.NewValue : null
 								};
 								break;
 
 							case "id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.TargetIdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? (ulong?)t1 : null,
 									After = p2 ? (ulong?)t2 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.Kick:
 					entry = new DiscordAuditLogKickEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var kickMember) ? kickMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.Prune:
 					entry = new DiscordAuditLogPruneEntry
 					{
 						Days = xac.Options.DeleteMemberDays,
 						Toll = xac.Options.MembersRemoved
 					};
 					break;
 
 				case AuditLogActionType.Ban:
 				case AuditLogActionType.Unban:
 					entry = new DiscordAuditLogBanEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var unbanMember) ? unbanMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.MemberUpdate:
 				case AuditLogActionType.MemberRoleUpdate:
 					entry = new DiscordAuditLogMemberUpdateEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var roleUpdMember) ? roleUpdMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrymbu = entry as DiscordAuditLogMemberUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "nick":
 								entrymbu.NicknameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "deaf":
 								entrymbu.DeafenChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "mute":
 								entrymbu.MuteChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "communication_disabled_until":
 								entrymbu.CommunicationDisabledUntilChange = new PropertyChange<DateTime?>
 								{
 									Before = (DateTime?)xc.OldValue,
 									After = (DateTime?)xc.NewValue
 								};
 								break;
 
 							case "$add":
 								entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							case "$remove":
 								entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.RoleCreate:
 				case AuditLogActionType.RoleDelete:
 				case AuditLogActionType.RoleUpdate:
 					entry = new DiscordAuditLogRoleUpdateEntry
 					{
 						Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryrol.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "color":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryrol.ColorChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "permissions":
 								entryrol.PermissionChange = new PropertyChange<Permissions?>
 								{
 									Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
 									After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
 								};
 								break;
 
 							case "position":
 								entryrol.PositionChange = new PropertyChange<int?>
 								{
 									Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
 								};
 								break;
 
 							case "mentionable":
 								entryrol.MentionableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "hoist":
 								entryrol.HoistChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "icon_hash":
 								entryrol.IconHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.InviteCreate:
 				case AuditLogActionType.InviteDelete:
 				case AuditLogActionType.InviteUpdate:
 					entry = new DiscordAuditLogInviteEntry();
 
 					var inv = new DiscordInvite
 					{
 						Discord = this.Discord,
 						Guild = new DiscordInviteGuild
 						{
 							Discord = this.Discord,
 							Id = this.Id,
 							Name = this.Name,
 							SplashHash = this.SplashHash
 						}
 					};
 
 					var entryinv = entry as DiscordAuditLogInviteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "max_age":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxAgeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "code":
 								inv.Code = xc.OldValueString ?? xc.NewValueString;
 
 								entryinv.CodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "temporary":
 								entryinv.TemporaryChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "inviter_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.InviterChange = new PropertyChange<DiscordMember>
 								{
 									Before = amd.TryGetValue(t1, out var propBeforeMember) ? propBeforeMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 									After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 
 								var ch = entryinv.ChannelChange.Before ?? entryinv.ChannelChange.After;
 								var cht = ch?.Type;
 								inv.Channel = new DiscordInviteChannel
 								{
 									Discord = this.Discord,
 									Id = p1 ? t1 : t2,
 									Name = ch?.Name,
 									Type = cht != null ? cht.Value : ChannelType.Unknown
 								};
 								break;
 
 							case "uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.UsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "max_uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxUsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							// TODO: Add changes for target application
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 
 					entryinv.Target = inv;
 					break;
 
 				case AuditLogActionType.WebhookCreate:
 				case AuditLogActionType.WebhookDelete:
 				case AuditLogActionType.WebhookUpdate:
 					entry = new DiscordAuditLogWebhookEntry
 					{
 						Target = ahd.TryGetValue(xac.TargetId.Value, out var webhook) ? webhook : new DiscordWebhook { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrywhk = entry as DiscordAuditLogWebhookEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "application_id": // ???
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.IdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? t1 : null,
 									After = p2 ? t2 : null
 								};
 								break;
 
 							case "name":
 								entrywhk.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 								break;
 
 							case "type": // ???
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entrywhk.TypeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "avatar_hash":
 								entrywhk.AvatarHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.EmojiCreate:
 				case AuditLogActionType.EmojiDelete:
 				case AuditLogActionType.EmojiUpdate:
 					entry = new DiscordAuditLogEmojiEntry
 					{
 						Target = this.EmojisInternal.TryGetValue(xac.TargetId.Value, out var target) ? target : new DiscordEmoji { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryemo = entry as DiscordAuditLogEmojiEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryemo.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StageInstanceCreate:
 				case AuditLogActionType.StageInstanceDelete:
 				case AuditLogActionType.StageInstanceUpdate:
 					entry = new DiscordAuditLogStageEntry
 					{
 						Target = this.StageInstancesInternal.TryGetValue(xac.TargetId.Value, out var stage) ? stage : new DiscordStageInstance { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysta = entry as DiscordAuditLogStageEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "topic":
 								entrysta.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "privacy_level":
 								entrysta.PrivacyLevelChange = new PropertyChange<StagePrivacyLevel?>
 								{
 									Before = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5) ? (StagePrivacyLevel?)t5 : null,
 									After = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6) ? (StagePrivacyLevel?)t6 : null,
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StickerCreate:
 				case AuditLogActionType.StickerDelete:
 				case AuditLogActionType.StickerUpdate:
 					entry = new DiscordAuditLogStickerEntry
 					{
 						Target = this.StickersInternal.TryGetValue(xac.TargetId.Value, out var sticker) ? sticker : new DiscordSticker { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysti = entry as DiscordAuditLogStickerEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrysti.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "description":
 								entrysti.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "tags":
 								entrysti.TagsChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "guild_id":
 								entrysti.GuildIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 							case "available":
 								entrysti.AvailabilityChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue,
 								};
 								break;
 							case "asset":
 								entrysti.AssetChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "id":
 								entrysti.IdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var oid) ? oid : null,
 									After = ulong.TryParse(xc.NewValueString, out var nid) ? nid : null
 								};
 								break;
 							case "type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.TypeChange = new PropertyChange<StickerType?>
 								{
 									Before = p1 ? (StickerType?)t5 : null,
 									After = p2 ? (StickerType?)t6 : null
 								};
 								break;
 							case "format_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.FormatChange = new PropertyChange<StickerFormat?>
 								{
 									Before = p1 ? (StickerFormat?)t5 : null,
 									After = p2 ? (StickerFormat?)t6 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 
 				case AuditLogActionType.MessageDelete:
 				case AuditLogActionType.MessageBulkDelete:
 				{
 					entry = new DiscordAuditLogMessageEntry();
 
 					var entrymsg = entry as DiscordAuditLogMessageEntry;
 
 					if (xac.Options != null)
 					{
 						entrymsg.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrymsg.MessageCount = xac.Options.Count;
 					}
 
 					if (entrymsg.Channel != null)
 					{
 						entrymsg.Target = this.Discord is DiscordClient dc
 							&& dc.MessageCache != null
-							&& dc.MessageCache.TryGet(xm => xm.Id == xac.TargetId.Value && xm.ChannelId == entrymsg.Channel.Id, out var msg)
+							&& dc.MessageCache.TryGetLastOrDefault(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);
+						dc.MessageCache?.TryGetLastOrDefault(x => x.Id == xac.Options.MessageId && x.ChannelId == xac.Options.ChannelId, out message);
 
 						entrypin.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrypin.Message = message ?? new DiscordMessage { Id = xac.Options.MessageId, Discord = this.Discord };
 					}
 
 					if (xac.TargetId.HasValue)
 					{
 						dc.UserCache.TryGetValue(xac.TargetId.Value, out var user);
 						entrypin.Target = user ?? new DiscordUser { Id = user.Id, Discord = this.Discord };
 					}
 
 					break;
 				}
 
 				case AuditLogActionType.BotAdd:
 				{
 					entry = new DiscordAuditLogBotAddEntry();
 
 					if (!(this.Discord is DiscordClient dc && xac.TargetId.HasValue))
 					{
 						break;
 					}
 
 					dc.UserCache.TryGetValue(xac.TargetId.Value, out var bot);
 					(entry as DiscordAuditLogBotAddEntry).TargetBot = bot ?? new DiscordUser { Id = xac.TargetId.Value, Discord = this.Discord };
 
 					break;
 				}
 
 				case AuditLogActionType.MemberMove:
 					entry = new DiscordAuditLogMemberMoveEntry();
 
 					if (xac.Options == null)
 					{
 						break;
 					}
 
 					var moveentry = entry as DiscordAuditLogMemberMoveEntry;
 
 					moveentry.UserCount = xac.Options.Count;
 					moveentry.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 					break;
 
 				case AuditLogActionType.MemberDisconnect:
 					entry = new DiscordAuditLogMemberDisconnectEntry
 					{
 						UserCount = xac.Options?.Count ?? 0
 					};
 					break;
 
 				case AuditLogActionType.IntegrationCreate:
 				case AuditLogActionType.IntegrationDelete:
 				case AuditLogActionType.IntegrationUpdate:
 					entry = new DiscordAuditLogIntegrationEntry();
 
 					var integentry = entry as DiscordAuditLogIntegrationEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "type":
 								integentry.Type = new PropertyChange<string>()
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "enable_emoticons":
 								integentry.EnableEmoticons = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "expire_behavior":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 							case "expire_grace_period":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ThreadCreate:
 				case AuditLogActionType.ThreadDelete:
 				case AuditLogActionType.ThreadUpdate:
 					entry = new DiscordAuditLogThreadEntry
 					{
 						Target = this.ThreadsInternal.TryGetValue(xac.TargetId.Value, out var thread) ? thread : new DiscordThreadChannel { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrythr = entry as DiscordAuditLogThreadEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrythr.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrythr.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "archived":
 								entrythr.ArchivedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "locked":
 								entrythr.LockedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "invitable":
 								entrythr.InvitableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "auto_archive_duration":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entrythr.AutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = p1 ? (ThreadAutoArchiveDuration?)t5 : null,
 									After = p2 ? (ThreadAutoArchiveDuration?)t6 : null
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrythr.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 				case AuditLogActionType.GuildScheduledEventCreate:
 				case AuditLogActionType.GuildScheduledEventDelete:
 				case AuditLogActionType.GuildScheduledEventUpdate:
 					entry = new DiscordAuditLogGuildScheduledEventEntry
 					{
 						Target = this.ScheduledEventsInternal.TryGetValue(xac.TargetId.Value, out var scheduledEvent) ? scheduledEvent : new DiscordScheduledEvent { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryse = entry as DiscordAuditLogGuildScheduledEventEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "channel_id":
 								entryse.ChannelIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 
 							case "name":
 								entryse.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "description":
 								entryse.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "location":
 								entryse.LocationChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "privacy_level":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.PrivacyLevelChange = new PropertyChange<ScheduledEventPrivacyLevel?>
 								{
 									Before = p1 ? (ScheduledEventPrivacyLevel?)t5 : null,
 									After = p2 ? (ScheduledEventPrivacyLevel?)t6 : null
 								};
 								break;
 
 							case "entity_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.EntityTypeChange = new PropertyChange<ScheduledEventEntityType?>
 								{
 									Before = p1 ? (ScheduledEventEntityType?)t5 : null,
 									After = p2 ? (ScheduledEventEntityType?)t6 : null
 								};
 								break;
 
 							case "status":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.StatusChange = new PropertyChange<ScheduledEventStatus?>
 								{
 									Before = p1 ? (ScheduledEventStatus?)t5 : null,
 									After = p2 ? (ScheduledEventStatus?)t6 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				// TODO: Handle ApplicationCommandPermissionUpdate
 				case AuditLogActionType.ApplicationCommandPermissionUpdate:
 					break;
 
 				default:
 					this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {0} - this should be reported to library developers", (int)xac.ActionType);
 					break;
 			}
 
 			if (entry == null)
 				continue;
 
 			entry.ActionCategory = xac.ActionType switch
 			{
 				AuditLogActionType.ChannelCreate or AuditLogActionType.EmojiCreate or AuditLogActionType.InviteCreate or AuditLogActionType.OverwriteCreate or AuditLogActionType.RoleCreate or AuditLogActionType.WebhookCreate or AuditLogActionType.IntegrationCreate or AuditLogActionType.StickerCreate or AuditLogActionType.StageInstanceCreate or AuditLogActionType.ThreadCreate or AuditLogActionType.GuildScheduledEventCreate => AuditLogActionCategory.Create,
 				AuditLogActionType.ChannelDelete or AuditLogActionType.EmojiDelete or AuditLogActionType.InviteDelete or AuditLogActionType.MessageDelete or AuditLogActionType.MessageBulkDelete or AuditLogActionType.OverwriteDelete or AuditLogActionType.RoleDelete or AuditLogActionType.WebhookDelete or AuditLogActionType.IntegrationDelete or AuditLogActionType.StickerDelete or AuditLogActionType.StageInstanceDelete or AuditLogActionType.ThreadDelete or AuditLogActionType.GuildScheduledEventDelete => AuditLogActionCategory.Delete,
 				AuditLogActionType.ChannelUpdate or AuditLogActionType.EmojiUpdate or AuditLogActionType.InviteUpdate or AuditLogActionType.MemberRoleUpdate or AuditLogActionType.MemberUpdate or AuditLogActionType.OverwriteUpdate or AuditLogActionType.RoleUpdate or AuditLogActionType.WebhookUpdate or AuditLogActionType.IntegrationUpdate or AuditLogActionType.StickerUpdate or AuditLogActionType.StageInstanceUpdate or AuditLogActionType.ThreadUpdate or AuditLogActionType.GuildScheduledEventUpdate => AuditLogActionCategory.Update,
 				_ => AuditLogActionCategory.Other,
 			};
 			entry.Discord = this.Discord;
 			entry.ActionType = xac.ActionType;
 			entry.Id = xac.Id;
 			entry.Reason = xac.Reason;
 			entry.UserResponsible = amd[xac.UserId];
 			entries.Add(entry);
 		}
 
 		return new ReadOnlyCollection<DiscordAuditLogEntry>(entries);
 	}
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessage.cs b/DisCatSharp/Entities/Message/DiscordMessage.cs
index f3e69e7c1..791e03faa 100644
--- a/DisCatSharp/Entities/Message/DiscordMessage.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessage.cs
@@ -1,881 +1,864 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
+using DisCatSharp.Net.Abstractions;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord text message.
 /// </summary>
 public class DiscordMessage : SnowflakeObject, IEquatable<DiscordMessage>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 	/// </summary>
 	internal DiscordMessage()
 	{
-		this._attachmentsLazy = new Lazy<IReadOnlyList<DiscordAttachment>>(() => new ReadOnlyCollection<DiscordAttachment>(this.AttachmentsInternal));
-		this._embedsLazy = new Lazy<IReadOnlyList<DiscordEmbed>>(() => new ReadOnlyCollection<DiscordEmbed>(this.EmbedsInternal));
-		this._mentionedChannelsLazy = new Lazy<IReadOnlyList<DiscordChannel>>(() => this.MentionedChannelsInternal != null
-				? new ReadOnlyCollection<DiscordChannel>(this.MentionedChannelsInternal)
-				: Array.Empty<DiscordChannel>());
-		this._mentionedRolesLazy = new Lazy<IReadOnlyList<DiscordRole>>(() => this.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(this.MentionedRolesInternal) : Array.Empty<DiscordRole>());
-		this.MentionedUsersLazy = new Lazy<IReadOnlyList<DiscordUser>>(() => new ReadOnlyCollection<DiscordUser>(this.MentionedUsersInternal));
 		this._reactionsLazy = new Lazy<IReadOnlyList<DiscordReaction>>(() => new ReadOnlyCollection<DiscordReaction>(this.ReactionsInternal));
 		this._stickersLazy = new Lazy<IReadOnlyList<DiscordSticker>>(() => new ReadOnlyCollection<DiscordSticker>(this.StickersInternal));
 		this._jumpLink = new Lazy<Uri>(() =>
 		{
 			string gid = null;
 			if (this.Channel != null)
 				gid = this.Channel is DiscordDmChannel
 					? "@me"
 					: this.Channel is DiscordThreadChannel
-					? this.INTERNAL_THREAD.GuildId.Value.ToString(CultureInfo.InvariantCulture)
+					? this.InternalThread.GuildId.Value.ToString(CultureInfo.InvariantCulture)
 					: this.Channel.GuildId.Value.ToString(CultureInfo.InvariantCulture);
 
 			var cid = this.ChannelId.ToString(CultureInfo.InvariantCulture);
 			var mid = this.Id.ToString(CultureInfo.InvariantCulture);
 
 			return new Uri($"https://{(this.Discord.Configuration.UseCanary ? "canary.discord.com" : this.Discord.Configuration.UsePtb ? "ptb.discord.com" : "discord.com")}/channels/{gid}/{cid}/{mid}");
 		});
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 	/// </summary>
 	/// <param name="other">The other message.</param>
 	internal DiscordMessage(DiscordMessage other)
 		: this()
 	{
 		this.Discord = other.Discord;
 
-		this.AttachmentsInternal = other.AttachmentsInternal; // the attachments cannot change, thus no need to copy and reallocate.
-		this.EmbedsInternal = new List<DiscordEmbed>(other.EmbedsInternal);
+		this.AttachmentsInternal = new(other.AttachmentsInternal);
+		this.EmbedsInternal = new(other.EmbedsInternal);
+		this.ComponentsInternal = new(other.ComponentsInternal);
 
 		if (other.MentionedChannelsInternal != null)
-			this.MentionedChannelsInternal = new List<DiscordChannel>(other.MentionedChannelsInternal);
-		if (other.MentionedRolesInternal != null)
-			this.MentionedRolesInternal = new List<DiscordRole>(other.MentionedRolesInternal);
-		if (other.MentionedRoleIds != null)
-			this.MentionedRoleIds = new List<ulong>(other.MentionedRoleIds);
-		this.MentionedUsersInternal = new List<DiscordUser>(other.MentionedUsersInternal);
-		this.ReactionsInternal = new List<DiscordReaction>(other.ReactionsInternal);
-		this.StickersInternal = new List<DiscordSticker>(other.StickersInternal);
+			this.MentionedChannelsInternal = new(other.MentionedChannelsInternal);
+		if (other.MentionedRoleIdsInternal != null)
+			this.MentionedRoleIdsInternal = new(other.MentionedRoleIdsInternal);
+		this.MentionedUsersInternal = new(other.MentionedUsersInternal);
+		this.ReactionsInternal = new(other.ReactionsInternal);
+		this.StickersInternal = new(other.StickersInternal);
 
 		this.Author = other.Author;
 		this.ChannelId = other.ChannelId;
 		this.Content = other.Content;
 		this.EditedTimestampRaw = other.EditedTimestampRaw;
 		this.Id = other.Id;
 		this.IsTts = other.IsTts;
 		this.MessageType = other.MessageType;
 		this.Pinned = other.Pinned;
 		this.TimestampRaw = other.TimestampRaw;
 		this.WebhookId = other.WebhookId;
 	}
 
 	/// <summary>
 	/// Gets the channel in which the message was sent.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Channel
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedChannel(this.ChannelId) ?? this._channel;
 		internal set => this._channel = value;
 	}
 
 	private DiscordChannel _channel;
 
 	/// <summary>
 	/// Gets the thread in which the message was sent.
 	/// </summary>
 	[JsonIgnore]
-	private DiscordThreadChannel INTERNAL_THREAD
+	internal DiscordThreadChannel InternalThread
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedThread(this.ChannelId) ?? this._thread;
 		set => this._thread = value;
 	}
 
 	private DiscordThreadChannel _thread;
 
 	/// <summary>
 	/// Gets the ID of the channel in which the message was sent.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the components this message was sent with.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordActionRowComponent> ComponentsInternal;
 	[JsonIgnore]
 	public IReadOnlyList<DiscordActionRowComponent> Components
 		=> new List<DiscordActionRowComponent>(this.ComponentsInternal);
 
 	/// <summary>
 	/// Gets the user or member that sent the message.
 	/// </summary>
 	[JsonProperty("author", NullValueHandling = NullValueHandling.Ignore)]
+	internal TransportUser AuthorInternal;
+	[JsonIgnore]
 	public DiscordUser Author { get; internal set; }
 
+	[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
+	internal TransportMember MemberInternal;
+	[JsonIgnore]
+	public DiscordMember Member { get; internal set; }
+
 	/// <summary>
 	/// Gets the message's content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's creation timestamp.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset Timestamp
 		=> !string.IsNullOrWhiteSpace(this.TimestampRaw) && DateTimeOffset.TryParse(this.TimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : this.CreationTimestamp;
 
 	/// <summary>
 	/// Gets the message's creation timestamp as raw string.
 	/// </summary>
 	[JsonProperty("timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string TimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the message's edit timestamp. Will be null if the message was not edited.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? EditedTimestamp
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw) && DateTimeOffset.TryParse(this.EditedTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			(DateTimeOffset?)dto : null;
 
 	/// <summary>
 	/// Gets the message's edit timestamp as raw string. Will be null if the message was not edited.
 	/// </summary>
 	[JsonProperty("edited_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string EditedTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets whether this message was edited.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsEdited
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw);
 
 	/// <summary>
 	/// Gets whether the message is a text-to-speech message.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsTts { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message mentions everyone.
 	/// </summary>
 	[JsonProperty("mention_everyone", NullValueHandling = NullValueHandling.Ignore)]
 	public bool MentionEveryone { get; internal set; }
 
 	/// <summary>
 	/// Gets users or members mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
-	public IReadOnlyList<DiscordUser> MentionedUsers
-		=> this.MentionedUsersLazy.Value;
-
+	public IReadOnlyCollection<DiscordUser> MentionedUsers
+		=> this.MentionedUsersInternal.Any() ? this.MentionedUsersInternal.Select(x => new DiscordUser(x)).ToArray(): Array.Empty<DiscordUser>();
 	[JsonProperty("mentions", NullValueHandling = NullValueHandling.Ignore)]
-	internal List<DiscordUser> MentionedUsersInternal = new();
-	[JsonIgnore]
-	internal readonly Lazy<IReadOnlyList<DiscordUser>> MentionedUsersLazy;
+	internal List<TransportUser> MentionedUsersInternal = new();
 
-	// TODO: this will probably throw an exception in DMs since it tries to wrap around a null List...
-	// this is probably low priority but need to find out a clean way to solve it...
 	/// <summary>
 	/// Gets roles mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
-	public IReadOnlyList<DiscordRole> MentionedRoles
-		=> this._mentionedRolesLazy.Value;
-
+	public IReadOnlyCollection<DiscordRole> MentionedRoles
+		=> this.MentionedRoleIdsInternal.Any() ? this.MentionedRolesInternal : Array.Empty<DiscordRole>();
 	[JsonIgnore]
-	internal List<DiscordRole> MentionedRolesInternal = new();
-
+	internal List<DiscordRole> MentionedRolesInternal
+		=> this.GuildId != null && this.Guild != null && this.MentionedRoleIdsInternal.Any() ? this.MentionedRoleIdsInternal.Select(x => this.Guild.GetRole(x)).ToList() : new();
 	[JsonProperty("mention_roles")]
-	internal List<ulong> MentionedRoleIds = new();
-
-	[JsonIgnore]
-	private readonly Lazy<IReadOnlyList<DiscordRole>> _mentionedRolesLazy;
+	internal List<ulong> MentionedRoleIdsInternal = new();
 
 	/// <summary>
 	/// Gets channels mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
-	public IReadOnlyList<DiscordChannel> MentionedChannels
-		=> this._mentionedChannelsLazy.Value;
+	public IReadOnlyCollection<DiscordChannel> MentionedChannels
+		=> this.MentionedChannelsInternal.Any()
+		? this.MentionedChannelsInternal.Select(
+			 x =>
+			 x.Type == ChannelType.NewsThread || x.Type == ChannelType.PublicThread || x.Type == ChannelType.PrivateThread
+			 ? x.GuildId.HasValue && this.Discord.Guilds.TryGetValue(x.GuildId.Value, out var guild) ? guild.GetThread(x.Id) : new DiscordThreadChannel(x.Name, x.Id, x.GuildId, x.Type ?? ChannelType.Unknown) { Discord = this.Discord }
+			 : x.GuildId.HasValue && this.Discord.Guilds.TryGetValue(x.GuildId.Value, out var guild2) ? guild2.GetChannel(x.Id) : new DiscordChannel(x.Name, x.Id, x.GuildId, x.Type ?? ChannelType.Unknown) { Discord = this.Discord }
+		).ToArray()
+		: Array.Empty<DiscordChannel>();
 
-	[JsonIgnore]
-	internal List<DiscordChannel> MentionedChannelsInternal = new();
-	[JsonIgnore]
-	private readonly Lazy<IReadOnlyList<DiscordChannel>> _mentionedChannelsLazy;
+	[JsonProperty("mention_channels", NullValueHandling = NullValueHandling.Ignore)]
+	internal List<ChannelMention> MentionedChannelsInternal = new();
 
 	/// <summary>
 	/// Gets files attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordAttachment> Attachments
-		=> this._attachmentsLazy.Value;
+		=> this.AttachmentsInternal;
 
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordAttachment> AttachmentsInternal = new();
-	[JsonIgnore]
-	private readonly Lazy<IReadOnlyList<DiscordAttachment>> _attachmentsLazy;
 
 	/// <summary>
 	/// Gets embeds attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordEmbed> Embeds
-		=> this._embedsLazy.Value;
+		=> this.EmbedsInternal;
 
 	[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordEmbed> EmbedsInternal = new();
-	[JsonIgnore]
-	private readonly Lazy<IReadOnlyList<DiscordEmbed>> _embedsLazy;
 
 	/// <summary>
 	/// Gets reactions used on this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordReaction> Reactions
 		=> this._reactionsLazy.Value;
 
 	[JsonProperty("reactions", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordReaction> ReactionsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordReaction>> _reactionsLazy;
 
 	/// <summary>
 	/// Gets the nonce sent with the message, if the message was sent by the client.
 	/// </summary>
 	[JsonProperty("nonce", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nonce { get; internal set; }
 
 
 	/// <summary>
 	/// Gets whether the message is pinned.
 	/// </summary>
 	[JsonProperty("pinned", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Pinned { get; internal set; }
 
 	/// <summary>
 	/// Gets the id of the webhook that generated this message.
 	/// </summary>
 	[JsonProperty("webhook_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? WebhookId { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of the message.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageType? MessageType { get; internal set; }
 
 	/// <summary>
 	/// Gets the message activity in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("activity", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageActivity Activity { get; internal set; }
 
 	/// <summary>
 	/// Gets the message application in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("application", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageApplication Application { get; internal set; }
 
 	/// <summary>
 	/// Gets the message application id in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// Gets the internal reference.
 	/// </summary>
 	[JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
 	internal InternalDiscordMessageReference? InternalReference { get; set; }
 
 	/// <summary>
 	/// Gets the original message reference from the crossposted message.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMessageReference Reference
 		=> this.InternalReference.HasValue ? this?.InternalBuildMessageReference() : null;
 
 	/// <summary>
 	/// Gets the bitwise flags for this message.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageFlags? Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message originated from a webhook.
 	/// </summary>
 	[JsonIgnore]
 	public bool WebhookMessage
 		=> this.WebhookId != null;
 
 	/// <summary>
 	/// Gets the jump link to this message.
 	/// </summary>
 	[JsonIgnore]
 	public Uri JumpLink => this._jumpLink.Value;
 	private readonly Lazy<Uri> _jumpLink;
 
 	/// <summary>
 	/// Gets stickers for this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordSticker> Stickers
 		=> this._stickersLazy.Value;
 
 	[JsonProperty("sticker_items", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordSticker> StickersInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordSticker>> _stickersLazy;
 
 	/// <summary>
 	/// Gets the guild id.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong? GuildId { get; set; }
+	/// <summary>
+	/// Gets the guild.
+	/// </summary>
+	[JsonIgnore]
+	internal DiscordGuild Guild { get; set; }
 
 	/// <summary>
 	/// Gets the message object for the referenced message
 	/// </summary>
 	[JsonProperty("referenced_message", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessage ReferencedMessage { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message is a response to an interaction.
 	/// </summary>
 	[JsonProperty("interaction", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageInteraction Interaction { get; internal set; }
 
 	/// <summary>
 	/// Gets the thread that was started from this message.
 	/// </summary>
 	[JsonProperty("thread", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannel Thread { get; internal set; }
 
 	/// <summary>
 	/// Build the message reference.
 	/// </summary>
 	internal DiscordMessageReference InternalBuildMessageReference()
 	{
 		var client = this.Discord as DiscordClient;
 		var guildId = this.InternalReference.Value.GuildId;
 		var channelId = this.InternalReference.Value.ChannelId;
 		var messageId = this.InternalReference.Value.MessageId;
 
 		var reference = new DiscordMessageReference();
 
 		if (guildId.HasValue)
 			reference.Guild = client.GuildsInternal.TryGetValue(guildId.Value, out var g)
 				? g
 				: new DiscordGuild
 				{
 					Id = guildId.Value,
 					Discord = client
 				};
 
 		var channel = client.InternalGetCachedChannel(channelId.Value);
 
 		if (channel == null)
 		{
 			reference.Channel = new DiscordChannel
 			{
 				Id = channelId.Value,
 				Discord = client
 			};
 
 			if (guildId.HasValue)
 				reference.Channel.GuildId = guildId.Value;
 		}
 
 		else reference.Channel = channel;
 
-		if (client.MessageCache != null && client.MessageCache.TryGet(m => m.Id == messageId.Value && m.ChannelId == channelId, out var msg))
+		if (client.MessageCache != null && client.MessageCache.TryGetLastOrDefault(m => m.Id == messageId.Value && m.ChannelId == channelId, out var msg))
 			reference.Message = msg;
 
 		else
 		{
 			reference.Message = new DiscordMessage
 			{
 				ChannelId = this.ChannelId,
 				Discord = client
 			};
 
 			if (messageId.HasValue)
 				reference.Message.Id = messageId.Value;
 		}
 
 		return reference;
 	}
 
 
 	/// <summary>
 	/// Gets the mentions.
 	/// </summary>
 	/// <returns>An array of IMentions.</returns>
 	private List<IMention> GetMentions()
 	{
 		var mentions = new List<IMention>();
 
-		if (this.ReferencedMessage != null && this.MentionedUsersInternal.Contains(this.ReferencedMessage.Author))
+		if (this.ReferencedMessage != null && this.MentionedUsers.Contains(this.ReferencedMessage.Author))
 			mentions.Add(new RepliedUserMention());
 
 		if (this.MentionedUsersInternal.Any())
-			mentions.AddRange(this.MentionedUsersInternal.Select(m => (IMention)new UserMention(m)));
+			mentions.AddRange(this.MentionedUsers.Select(m => (IMention)new UserMention(m)));
 
-		if (this.MentionedRoleIds.Any())
-			mentions.AddRange(this.MentionedRoleIds.Select(r => (IMention)new RoleMention(r)));
+		if (this.MentionedRoleIdsInternal.Any())
+			mentions.AddRange(this.MentionedRoleIdsInternal.Select(r => (IMention)new RoleMention(r)));
 
 		return mentions;
 	}
 
 	/// <summary>
 	/// Populates the mentions.
 	/// </summary>
 	internal void PopulateMentions()
 	{
 		var guild = this.Channel?.Guild;
-		this.MentionedUsersInternal ??= new List<DiscordUser>();
-		this.MentionedRolesInternal ??= new List<DiscordRole>();
-		this.MentionedChannelsInternal ??= new List<DiscordChannel>();
+		this.MentionedUsersInternal ??= new();
+		this.MentionedRoleIdsInternal ??= new();
+		this.MentionedChannelsInternal ??= new();
 
 		var mentionedUsers = new HashSet<DiscordUser>(new DiscordUserComparer());
 		if (guild != null)
 		{
-			foreach (var usr in this.MentionedUsersInternal)
+			foreach (var usr in this.MentionedUsers)
 			{
 				usr.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
-
-				mentionedUsers.Add(guild.MembersInternal.TryGetValue(usr.Id, out var member) ? member : usr);
 			}
 		}
-		if (!string.IsNullOrWhiteSpace(this.Content))
-		{
-			//mentionedUsers.UnionWith(Utilities.GetUserMentions(this).Select(this.Discord.GetCachedOrEmptyUserInternal));
-			if (guild != null)
-			{
-				//this._mentionedRoles = this._mentionedRoles.Union(Utilities.GetRoleMentions(this).Select(xid => guild.GetRole(xid))).ToList();
-				this.MentionedRolesInternal = this.MentionedRolesInternal.Union(this.MentionedRoleIds.Select(xid => guild.GetRole(xid))).ToList();
-				this.MentionedChannelsInternal = this.MentionedChannelsInternal.Union(Utilities.GetChannelMentions(this).Select(xid => guild.GetChannel(xid))).ToList();
-			}
-		}
-
-		this.MentionedUsersInternal = mentionedUsers.ToList();
 	}
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="embed">New embed.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<DiscordEmbed> embed = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, embed.Map(v => new[] { v }).ValueOr(Array.Empty<DiscordEmbed>()), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embed">New embed.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<DiscordEmbed> embed = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embed.Map(v => new[] { v }).ValueOr(Array.Empty<DiscordEmbed>()), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embeds">New embeds.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="builder">The builder of the message to edit.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> ModifyAsync(DiscordMessageBuilder builder)
 	{
 		builder.Validate(true);
 		return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, Optional.Some(builder.Embeds.AsEnumerable()), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? Optional.Some(builder.Attachments.AsEnumerable()) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? Optional.Some(this.Attachments.AsEnumerable()) : Array.Empty<DiscordAttachment>() : null);
 	}
 
 	/// <summary>
 	/// Edits the message embed suppression.
 	/// </summary>
 	/// <param name="suppress">Suppress embeds.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifySuppressionAsync(bool suppress = false)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, default, default, suppress, default, default);
 
 	/// <summary>
 	/// Clears all attachments from the message.
 	/// </summary>
 	/// <returns></returns>
 	public Task<DiscordMessage> ClearAttachmentsAsync()
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, default, default, Array.Empty<DiscordAttachment>());
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="action">The builder of the message to edit.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> ModifyAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		builder.Validate(true);
 		return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, Optional.Some(builder.Embeds.AsEnumerable()), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? Optional.Some(builder.Attachments.AsEnumerable()) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? Optional.Some(this.Attachments.AsEnumerable()) : Array.Empty<DiscordAttachment>() : null);
 	}
 
 	/// <summary>
 	/// Deletes the message.
 	/// </summary>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Creates a thread.
 	/// Depending on the <see cref="ChannelType"/> of the parent channel it's either a <see cref="ChannelType.PublicThread"/> or a <see cref="ChannelType.NewsThread"/>.
 	/// </summary>
 	/// <param name="name">The name of the thread.</param>
 	/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/></param>
 	/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 	/// <param name="reason">The reason.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified.</exception>
 	public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, int? rateLimitPerUser = null, string reason = null) =>
 		Utilities.CheckThreadAutoArchiveDurationFeature(this.Channel.Guild, autoArchiveDuration)
 			? await this.Discord.ApiClient.CreateThreadAsync(this.ChannelId, this.Id, name, autoArchiveDuration, this.Channel.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, reason)
 			: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 	/// <summary>
 	/// Pins the message in its channel.
 	/// </summary>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task PinAsync()
 		=> this.Discord.ApiClient.PinMessageAsync(this.ChannelId, this.Id);
 
 	/// <summary>
 	/// Unpins the message in its channel.
 	/// </summary>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnpinAsync()
 		=> this.Discord.ApiClient.UnpinMessageAsync(this.ChannelId, this.Id);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="content">Message content to respond with.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(string content)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="content">Message content to respond with.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="builder">The Discord message builder.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="action">The Discord message builder.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		return this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 	}
 
 	/// <summary>
 	/// Creates a reaction to this message.
 	/// </summary>
 	/// <param name="emoji">The emoji you want to react with, either an emoji or name:id</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task CreateReactionAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.CreateReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Deletes your own reaction
 	/// </summary>
 	/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id</param>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOwnReactionAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.DeleteOwnReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Deletes another user's reaction.
 	/// </summary>
 	/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id.</param>
 	/// <param name="user">Member you want to remove the reaction for</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteReactionAsync(DiscordEmoji emoji, DiscordUser user, string reason = null)
 		=> this.Discord.ApiClient.DeleteUserReactionAsync(this.ChannelId, this.Id, user.Id, emoji.ToReactionString(), reason);
 
 	/// <summary>
 	/// Gets users that reacted with this emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to react with.</param>
 	/// <param name="limit">Limit of users to fetch.</param>
 	/// <param name="after">Fetch users after this user's id.</param>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 		=> this.GetReactionsInternalAsync(emoji, limit, after);
 
 	/// <summary>
 	/// Deletes all reactions for this message.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAllReactionsAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteAllReactionsAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Deletes all reactions of a specific reaction for this message.
 	/// </summary>
 	/// <param name="emoji">The emoji to clear, either an emoji or name:id.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteReactionsEmojiAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.DeleteReactionsEmojiAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Gets the reactions.
 	/// </summary>
 	/// <param name="emoji">The emoji to search for.</param>
 	/// <param name="limit">The limit of results.</param>
 	/// <param name="after">Get the reasctions after snowflake.</param>
 	private async Task<IReadOnlyList<DiscordUser>> GetReactionsInternalAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 	{
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of reactions' users.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordUser>();
 
 		var users = new List<DiscordUser>(limit);
 		var remaining = limit;
 		var last = after;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetReactionsAsync(this.Channel.Id, this.Id, emoji.ToReactionString(), last, fetchSize).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			users.AddRange(fetch);
 			last = fetch.LastOrDefault()?.Id;
 		} while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordUser>(users);
 	}
 
 	/// <summary>
 	/// Returns a string representation of this message.
 	/// </summary>
 	/// <returns>String representation of this message.</returns>
 	public override string ToString()
 		=> $"Message {this.Id}; Attachment count: {this.AttachmentsInternal.Count}; Embed count: {this.EmbedsInternal.Count}; Contents: {this.Content}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMessage"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordMessage"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordMessage);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMessage"/> is equal to another <see cref="DiscordMessage"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordMessage"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordMessage"/> is equal to this <see cref="DiscordMessage"/>.</returns>
 	public bool Equals(DiscordMessage e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.ChannelId == e.ChannelId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordMessage"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordMessage"/>.</returns>
 	public override int GetHashCode()
 	{
 		var hash = 13;
 
 		hash = (hash * 7) + this.Id.GetHashCode();
 		hash = (hash * 7) + this.ChannelId.GetHashCode();
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMessage"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First message to compare.</param>
 	/// <param name="e2">Second message to compare.</param>
 	/// <returns>Whether the two messages are equal.</returns>
 	public static bool operator ==(DiscordMessage e1, DiscordMessage e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null)
 			&& (o1 == null || o2 != null)
 			&& ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.ChannelId == e2.ChannelId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMessage"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First message to compare.</param>
 	/// <param name="e2">Second message to compare.</param>
 	/// <returns>Whether the two messages are not equal.</returns>
 	public static bool operator !=(DiscordMessage e1, DiscordMessage e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Message/Mentions.cs b/DisCatSharp/Entities/Message/Mentions.cs
index b1d1c397b..16e7c4549 100644
--- a/DisCatSharp/Entities/Message/Mentions.cs
+++ b/DisCatSharp/Entities/Message/Mentions.cs
@@ -1,132 +1,157 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 
+using DisCatSharp.Enums;
+
+using Newtonsoft.Json;
+
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Interface for mentionables
 /// </summary>
 public interface IMention { }
 
 
 /// <summary>
 /// Allows a reply to ping the user being replied to.
 /// </summary>
 public readonly struct RepliedUserMention : IMention
 {
 	//This is pointless because new RepliedUserMention() will work, but it is here for consistency with the other mentionables.
 	/// <summary>
 	/// Mention the user being replied to.  Alias to <see cref="RepliedUserMention()"/> constructor.
 	/// </summary>
 	public static readonly RepliedUserMention All = new();
 }
 
 /// <summary>
 /// Allows @everyone and @here pings to mention in the message.
 /// </summary>
 public readonly struct EveryoneMention : IMention
 {
 	//This is pointless because new EveryoneMention() will work, but it is here for consistency with the other mentionables.
 	/// <summary>
 	/// Allow the mentioning of @everyone and @here. Alias to <see cref="EveryoneMention()"/> constructor.
 	/// </summary>
 	public static readonly EveryoneMention All = new();
 }
 
 /// <summary>
 /// Allows @user pings to mention in the message.
 /// </summary>
 public readonly struct UserMention : IMention
 {
 	/// <summary>
 	/// Allow mentioning of all users. Alias to <see cref="UserMention()"/> constructor.
 	/// </summary>
 	public static readonly UserMention All = new();
 
 	/// <summary>
 	/// Optional Id of the user that is allowed to be mentioned. If null, then all user mentions will be allowed.
 	/// </summary>
 	public ulong? Id { get; }
 
 	/// <summary>
 	/// Allows the specific user to be mentioned
 	/// </summary>
 	/// <param name="id"></param>
 	public UserMention(ulong id) { this.Id = id; }
 
 	/// <summary>
 	/// Allows the specific user to be mentioned
 	/// </summary>
 	/// <param name="user"></param>
 	public UserMention(DiscordUser user) : this(user.Id) { }
 
 	public static implicit operator UserMention(DiscordUser user) => new(user.Id);
 }
 
 /// <summary>
 /// Allows @role pings to mention in the message.
 /// </summary>
 public readonly struct RoleMention : IMention
 {
 	/// <summary>
 	/// Allow the mentioning of all roles.  Alias to <see cref="RoleMention()"/> constructor.
 	/// </summary>
 	public static readonly RoleMention All = new();
 
 	/// <summary>
 	/// Optional Id of the role that is allowed to be mentioned. If null, then all role mentions will be allowed.
 	/// </summary>
 	public ulong? Id { get; }
 
 	/// <summary>
 	/// Allows the specific id to be mentioned
 	/// </summary>
 	/// <param name="id"></param>
 	public RoleMention(ulong id) { this.Id = id; }
 
 	/// <summary>
 	/// Allows the specific role to be mentioned
 	/// </summary>
 	/// <param name="role"></param>
 	public RoleMention(DiscordRole role) : this(role.Id) { }
 
 	public static implicit operator RoleMention(DiscordRole role) => new(role.Id);
 }
 
 /// <summary>
 /// Contains static instances of common mention patterns.
 /// </summary>
 public static class Mentions
 {
 	/// <summary>
 	/// All possible mentions - @everyone + @here, users, and roles.
 	/// </summary>
 	public static IEnumerable<IMention> All { get; } = new IMention[] { EveryoneMention.All, UserMention.All, RoleMention.All };
 
 	/// <summary>
 	/// No mentions allowed.
 	/// </summary>
 	public static IEnumerable<IMention> None { get; } = Array.Empty<IMention>();
 }
+
+public class ChannelMention : SnowflakeObject
+{
+	/// <summary>
+	/// Gets the guild id.
+	/// </summary>
+	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
+	public ulong? GuildId { get; internal set; }
+
+	/// <summary>
+	/// Gets the channel type.
+	/// </summary>
+	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
+	public ChannelType? Type { get; internal set; }
+
+	/// <summary>
+	/// Gets the channel name.
+	/// </summary>
+	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
+	public string Name { get; internal set; }
+}
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
index d221e4eea..c316c7416 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
@@ -1,645 +1,651 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord thread channel.
 /// </summary>
 public class DiscordThreadChannel : DiscordChannel, IEquatable<DiscordThreadChannel>
 {
 	/// <summary>
 	/// Gets ID of the owner that started this thread.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong OwnerId { get; internal set; }
 
 	/// <summary>
 	/// Gets the name of this thread.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public new string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of this thread.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public new ChannelType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this thread is private.
 	/// </summary>
 	[JsonIgnore]
 	public new bool IsPrivate
 		=> this.Type == ChannelType.PrivateThread;
 
 	/// <summary>
 	/// Gets the ID of the last message sent in this thread.
 	/// </summary>
 	[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 	public new ulong? LastMessageId { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the slowmode delay configured for this thread.</para>
 	/// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slowmode.</para>
 	/// </summary>
 	[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
 	public new int? PerUserRateLimit { get; internal set; }
 
 	/// <summary>
 	/// Gets an approximate count of messages in a thread, stops counting at 50.
 	/// </summary>
 	[JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MessageCount { get; internal set; }
 
 	/// <summary>
 	/// Gets an approximate count of users in a thread, stops counting at 50.
 	/// </summary>
 	[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MemberCount { get; internal set; }
 
 	/// <summary>
 	/// Represents the current member for this thread. This will have a value if the user has joined the thread.
 	/// </summary>
 	[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannelMember CurrentMember { get; internal set; }
 
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned in this thread.
 	/// </summary>
 	[JsonIgnore]
 	public new DateTimeOffset? LastPinTimestamp
 		=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned in this thread as raw string.
 	/// </summary>
 	[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal new string LastPinTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the threads metadata.
 	/// </summary>
 	[JsonProperty("thread_metadata", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannelMetadata ThreadMetadata { get; internal set; }
 
 	/// <summary>
 	/// Gets the thread members object.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordThreadChannelMember> ThreadMembers => new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannelMember>(this.ThreadMembersInternal);
 
 	[JsonProperty("thread_member", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordThreadChannelMember> ThreadMembersInternal;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
 	/// </summary>
-	internal DiscordThreadChannel()
+	internal DiscordThreadChannel() : base()
+	{ }
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
+	/// </summary>
+	internal DiscordThreadChannel(string name, ulong id, ulong? guildId, ChannelType? type) : base(name, id, guildId, type)
 	{ }
 
 	#region Methods
 
 	/// <summary>
 	/// Deletes a thread.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteThreadAsync(this.Id, reason);
 
 	/// <summary>
 	/// Modifies the current thread.
 	/// </summary>
 	/// <param name="action">Action to perform on this thread</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>.</exception>
 	public Task ModifyAsync(Action<ThreadEditModel> action)
 	{
 		var mdl = new ThreadEditModel();
 		action(mdl);
 
 		var canContinue = !mdl.AutoArchiveDuration.HasValue || !mdl.AutoArchiveDuration.Value.HasValue || Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.AutoArchiveDuration.Value.Value);
 		if (mdl.Invitable.HasValue)
 		{
 			canContinue = this.Guild.Features.CanCreatePrivateThreads;
 		}
 		return canContinue ? this.Discord.ApiClient.ModifyThreadAsync(this.Id, mdl.Name, mdl.Locked, mdl.Archived, mdl.PerUserRateLimit, mdl.AutoArchiveDuration, mdl.Invitable, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(mdl.AutoArchiveDuration.Value.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 	}
 
 	/// <summary>
 	/// Archives a thread.
 	/// </summary>
 	/// <param name="locked">Whether the thread should be locked.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ArchiveAsync(bool locked = true, string reason = null)
 		=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, locked, true, null, null, null, reason: reason);
 
 	/// <summary>
 	/// Unarchives a thread.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnarchiveAsync(string reason = null)
 		=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, null, false, null, null, null, reason: reason);
 
 	/// <summary>
 	/// Gets the members of a thread. Needs the <see cref="DiscordIntents.GuildMembers"/> intent.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordThreadChannelMember>> GetMembersAsync()
 		=> await this.Discord.ApiClient.GetThreadMembersAsync(this.Id);
 
 	/// <summary>
 	/// Adds a member to this thread.
 	/// </summary>
 	/// <param name="memberId">The member id to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.AddThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Adds a member to this thread.
 	/// </summary>
 	/// <param name="member">The member to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddMemberAsync(DiscordMember member)
 		=> this.AddMemberAsync(member.Id);
 
 	/// <summary>
 	/// Gets a member in this thread.
 	/// </summary>
 	/// <param name="memberId">The member to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordThreadChannelMember> GetMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Gets a member in this thread.
 	/// </summary>
 	/// <param name="member">The member to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordThreadChannelMember> GetMemberAsync(DiscordMember member)
 		=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member.Id);
 
 	/// <summary>
 	/// Removes a member from this thread.
 	/// </summary>
 	/// <param name="memberId">The member id to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Removes a member from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="member">The member to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveMemberAsync(DiscordMember member)
 		=> this.RemoveMemberAsync(member.Id);
 
 	/// <summary>
 	/// Adds a role to this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="roleId">The role id to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task AddRoleAsync(ulong roleId)
 	{
 		var role = this.Guild.GetRole(roleId);
 		var members = await this.Guild.GetAllMembersAsync();
 		var roleMembers = members.Where(m => m.Roles.Contains(role));
 		foreach (var member in roleMembers)
 		{
 			await this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member.Id);
 		}
 	}
 
 	/// <summary>
 	/// Adds a role to this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="role">The role to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddRoleAsync(DiscordRole role)
 		=> this.AddRoleAsync(role.Id);
 
 	/// <summary>
 	/// Removes a role from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="roleId">The role id to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task RemoveRoleAsync(ulong roleId)
 	{
 		var role = this.Guild.GetRole(roleId);
 		var members = await this.Guild.GetAllMembersAsync();
 		var roleMembers = members.Where(m => m.Roles.Contains(role));
 		foreach (var member in roleMembers)
 		{
 			await this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member.Id);
 		}
 	}
 
 	/// <summary>
 	/// Removes a role to from thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="role">The role to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveRoleAsync(DiscordRole role)
 		=> this.RemoveRoleAsync(role.Id);
 
 	/// <summary>
 	/// Joins a thread.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task JoinAsync()
 		=> this.Discord.ApiClient.JoinThreadAsync(this.Id);
 
 	/// <summary>
 	/// Leaves a thread.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task LeaveAsync()
 		=> this.Discord.ApiClient.LeaveThreadAsync(this.Id);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(string content) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, null, new[] { embed }, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, new[] { embed }, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="builder">The builder with all the items to thread.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="action">The builder with all the items to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 		return !this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 	}
 
 	/// <summary>
 	/// Returns a specific message
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new async Task<DiscordMessage> GetMessageAsync(ulong id) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& this.Discord is DiscordClient dc
 		&& dc.MessageCache != null
-		&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
+		&& dc.MessageCache.TryGetLastOrDefault(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 			? msg
 			: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Returns a list of messages before a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="before">Message to fetch before from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, before, null, null);
 
 	/// <summary>
 	/// Returns a list of messages after a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="after">Message to fetch after from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, after, null);
 
 	/// <summary>
 	/// Returns a list of messages around a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="around">Message to fetch around from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, null, around);
 
 	/// <summary>
 	/// Returns a list of messages from the last message in the thread.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
 		this.GetMessagesInternalAsync(limit, null, null, null);
 
 	/// <summary>
 	/// Returns a list of messages
 	/// </summary>
 	/// <param name="limit">How many messages should be returned.</param>
 	/// <param name="before">Get messages before snowflake.</param>
 	/// <param name="after">Get messages after snowflake.</param>
 	/// <param name="around">Get messages around snowflake.</param>
 	private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
 	{
 		if (this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread)
 			throw new ArgumentException("Cannot get the messages of a non-thread channel.");
 
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of messages.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordMessage>();
 
 		//return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
 		if (limit > 100 && around != null)
 			throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
 		var msgs = new List<DiscordMessage>(limit);
 		var remaining = limit;
 		ulong? last = null;
 		var isAfter = after != null;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			if (!isAfter)
 			{
 				msgs.AddRange(fetch);
 				last = fetch.LastOrDefault()?.Id;
 			}
 			else
 			{
 				msgs.InsertRange(0, fetch);
 				last = fetch.FirstOrDefault()?.Id;
 			}
 		}
 		while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordMessage>(msgs);
 	}
 
 	/// <summary>
 	/// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
 	/// </summary>
 	/// <param name="messages">A collection of messages to delete.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
 	{
 		// don't enumerate more than once
 		var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
 		if (messages == null || !msgs.Any())
 			throw new ArgumentException("You need to specify at least one message to delete.");
 
 		if (msgs.Length < 2)
 		{
 			await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
 			return;
 		}
 
 		for (var i = 0; i < msgs.Length; i += 100)
 			await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a message
 	/// </summary>
 	/// <param name="message">The message to be deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task DeleteMessageAsync(DiscordMessage message, string reason = null)
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 	/// <summary>
 	/// Post a typing indicator
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task TriggerTypingAsync() =>
 		this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
 			? throw new ArgumentException("Cannot start typing in a non-text channel.")
 			: this.Discord.ApiClient.TriggerTypingAsync(this.Id);
 
 	/// <summary>
 	/// Returns all pinned messages
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission or the client is missing <see cref="Permissions.ReadMessageHistory"/>.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync() =>
 		this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.News
 			? throw new ArgumentException("A non-thread channel does not have pinned messages.")
 			: this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
 
 	/// <summary>
 	/// Returns a string representation of this thread.
 	/// </summary>
 	/// <returns>String representation of this thread.</returns>
 	public override string ToString()
 		=> this.Type switch
 		{
 			ChannelType.NewsThread => $"News thread {this.Name} ({this.Id})",
 			ChannelType.PublicThread => $"Thread {this.Name} ({this.Id})",
 			ChannelType.PrivateThread => $"Private thread {this.Name} ({this.Id})",
 			_ => $"Thread {this.Name} ({this.Id})",
 		};
 	#endregion
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordThreadChannel"/>.</returns>
 	public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannel);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannel"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannel"/>.</returns>
 	public bool Equals(DiscordThreadChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordThreadChannel"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordThreadChannel"/>.</returns>
 	public override int GetHashCode() => this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are equal.</returns>
 	public static bool operator ==(DiscordThreadChannel e1, DiscordThreadChannel e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are not equal.</returns>
 	public static bool operator !=(DiscordThreadChannel e1, DiscordThreadChannel e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/RingBuffer.cs b/DisCatSharp/RingBuffer.cs
index 0e7d74b98..91c0da3ec 100644
--- a/DisCatSharp/RingBuffer.cs
+++ b/DisCatSharp/RingBuffer.cs
@@ -1,238 +1,259 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
 using DisCatSharp.Common;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A circular buffer collection.
 /// </summary>
 /// <typeparam name="T">Type of elements within this ring buffer.</typeparam>
 public class RingBuffer<T> : ICollection<T>
 {
 	/// <summary>
 	/// Gets the current index of the buffer items.
 	/// </summary>
 	public int CurrentIndex { get; protected set; }
 
 	/// <summary>
 	/// Gets the capacity of this ring buffer.
 	/// </summary>
 	public int Capacity { get; protected set; }
 
 	/// <summary>
 	/// Gets the number of items in this ring buffer.
 	/// </summary>
 	public int Count
 		=> this._reachedEnd ? this.Capacity : this.CurrentIndex;
 
 	/// <summary>
 	/// Gets whether this ring buffer is read-only.
 	/// </summary>
 	public bool IsReadOnly
 		=> false;
 
 	/// <summary>
 	/// Gets or sets the internal collection of items.
 	/// </summary>
 	protected T[] InternalBuffer { get; set; }
 	private bool _reachedEnd;
 
 	/// <summary>
 	/// Creates a new ring buffer with specified size.
 	/// </summary>
 	/// <param name="size">Size of the buffer to create.</param>
 	/// <exception cref="System.ArgumentOutOfRangeException" />
 	public RingBuffer(int size)
 	{
 		if (size <= 0)
 			throw new ArgumentOutOfRangeException(nameof(size), "Size must be positive.");
 
 		this.CurrentIndex = 0;
 		this.Capacity = size;
 		this.InternalBuffer = new T[this.Capacity];
 	}
 
 	/// <summary>
 	/// Creates a new ring buffer, filled with specified elements.
 	/// </summary>
 	/// <param name="elements">Elements to fill the buffer with.</param>
 	/// <exception cref="System.ArgumentException" />
 	/// <exception cref="System.ArgumentOutOfRangeException" />
 	public RingBuffer(IEnumerable<T> elements)
 		: this(elements, 0)
 	{ }
 
 	/// <summary>
 	/// Creates a new ring buffer, filled with specified elements, and starting at specified index.
 	/// </summary>
 	/// <param name="elements">Elements to fill the buffer with.</param>
 	/// <param name="index">Starting element index.</param>
 	/// <exception cref="System.ArgumentException" />
 	/// <exception cref="System.ArgumentOutOfRangeException" />
 	public RingBuffer(IEnumerable<T> elements, int index)
 	{
 		if (elements == null || !elements.Any())
 			throw new ArgumentException("The collection cannot be null or empty.", nameof(elements));
 
 		this.CurrentIndex = index;
 		this.InternalBuffer = elements.ToArray();
 		this.Capacity = this.InternalBuffer.Length;
 
 		if (this.CurrentIndex >= this.InternalBuffer.Length || this.CurrentIndex < 0)
 			throw new ArgumentOutOfRangeException(nameof(index), "Index must be less than buffer capacity, and greater than zero.");
 	}
 
 	/// <summary>
 	/// Inserts an item into this ring buffer.
 	/// </summary>
 	/// <param name="item">Item to insert.</param>
 	public void Add(T item)
 	{
 		this.InternalBuffer[this.CurrentIndex++] = item;
 
 		if (this.CurrentIndex == this.Capacity)
 		{
 			this.CurrentIndex = 0;
 			this._reachedEnd = true;
 		}
 	}
 
 	/// <summary>
-	/// Gets first item from the buffer that matches the predicate.
+	/// Gets the first item from the buffer that matches the predicate.
 	/// </summary>
 	/// <param name="predicate">Predicate used to find the item.</param>
 	/// <param name="item">Item that matches the predicate, or default value for the type of the items in this ring buffer, if one is not found.</param>
 	/// <returns>Whether an item that matches the predicate was found or not.</returns>
-	public bool TryGet(Func<T, bool> predicate, out T item)
+	public bool TryGetFirstOrDefault(Func<T, bool> predicate, out T item)
 	{
 		for (var i = this.CurrentIndex; i < this.InternalBuffer.Length; i++)
 		{
 			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 			{
 				item = this.InternalBuffer[i];
 				return true;
 			}
 		}
 		for (var i = 0; i < this.CurrentIndex; i++)
 		{
 			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 			{
 				item = this.InternalBuffer[i];
 				return true;
 			}
 		}
 
 		item = default;
 		return false;
 	}
 
+	/// <summary>
+	/// Gets the last item from the buffer that matches the predicate.
+	/// </summary>
+	/// <param name="predicate">Predicate used to find the item.</param>
+	/// <param name="item">Item that matches the predicate, or default value for the type of the items in this ring buffer, if one is not found.</param>
+	/// <returns>Whether an item that matches the predicate was found or not.</returns>
+	public bool TryGetLastOrDefault(Func<T, bool> predicate, out T item)
+	{
+		for (var i = this.CurrentIndex; i > 0; i--)
+		{
+			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
+			{
+				item = this.InternalBuffer[i];
+				return true;
+			}
+		}
+
+		item = default;
+		return false;
+	}
+
 	/// <summary>
 	/// Clears this ring buffer and resets the current item index.
 	/// </summary>
 	public void Clear()
 	{
 		this.InternalBuffer.Populate(default);
 		this.CurrentIndex = 0;
 	}
 
 	/// <summary>
 	/// Checks whether given item is present in the buffer. This method is not implemented. Use <see cref="Contains(Func{T, bool})"/> instead.
 	/// </summary>
 	/// <param name="item">Item to check for.</param>
 	/// <returns>Whether the buffer contains the item.</returns>
 	/// <exception cref="System.NotImplementedException" />
 	public bool Contains(T item) => throw new NotImplementedException("This method is not implemented. Use .Contains(predicate) instead.");
 
 	/// <summary>
 	/// Checks whether given item is present in the buffer using given predicate to find it.
 	/// </summary>
 	/// <param name="predicate">Predicate used to check for the item.</param>
 	/// <returns>Whether the buffer contains the item.</returns>
 	public bool Contains(Func<T, bool> predicate) => this.InternalBuffer.Any(predicate);
 
 	/// <summary>
 	/// Copies this ring buffer to target array, attempting to maintain the order of items within.
 	/// </summary>
 	/// <param name="array">Target array.</param>
 	/// <param name="index">Index starting at which to copy the items to.</param>
 	public void CopyTo(T[] array, int index)
 	{
 		if (array.Length - index < 1)
 			throw new ArgumentException("Target array is too small to contain the elements from this buffer.", nameof(array));
 
 		var ci = 0;
 		for (var i = this.CurrentIndex; i < this.InternalBuffer.Length; i++)
 			array[ci++] = this.InternalBuffer[i];
 		for (var i = 0; i < this.CurrentIndex; i++)
 			array[ci++] = this.InternalBuffer[i];
 	}
 
 	/// <summary>
 	/// Removes an item from the buffer. This method is not implemented. Use <see cref="Remove(Func{T, bool})"/> instead.
 	/// </summary>
 	/// <param name="item">Item to remove.</param>
 	/// <returns>Whether an item was removed or not.</returns>
 	public bool Remove(T item) => throw new NotImplementedException("This method is not implemented. Use .Remove(predicate) instead.");
 
 	/// <summary>
 	/// Removes an item from the buffer using given predicate to find it.
 	/// </summary>
 	/// <param name="predicate">Predicate used to find the item.</param>
 	/// <returns>Whether an item was removed or not.</returns>
 	public bool Remove(Func<T, bool> predicate)
 	{
 		for (var i = 0; i < this.InternalBuffer.Length; i++)
 		{
 			if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 			{
 				this.InternalBuffer[i] = default;
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/// <summary>
 	/// Returns an enumerator for this ring buffer.
 	/// </summary>
 	/// <returns>Enumerator for this ring buffer.</returns>
 	public IEnumerator<T> GetEnumerator() =>
 		!this._reachedEnd
 			? this.InternalBuffer.AsEnumerable().GetEnumerator()
 			: this.InternalBuffer.Skip(this.CurrentIndex)
 				.Concat(this.InternalBuffer.Take(this.CurrentIndex))
 				.GetEnumerator();
 
 	/// <summary>
 	/// Returns an enumerator for this ring buffer.
 	/// </summary>
 	/// <returns>Enumerator for this ring buffer.</returns>
 	IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 }