diff --git a/DisCatSharp.CommandsNext/Attributes/RequireBotPermissionsAttribute.cs b/DisCatSharp.CommandsNext/Attributes/RequireBotPermissionsAttribute.cs
index 5d560528b..f5149579b 100644
--- a/DisCatSharp.CommandsNext/Attributes/RequireBotPermissionsAttribute.cs
+++ b/DisCatSharp.CommandsNext/Attributes/RequireBotPermissionsAttribute.cs
@@ -1,78 +1,83 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Enums;
 
 namespace DisCatSharp.CommandsNext.Attributes;
 
 /// <summary>
 /// Defines that usage of this command is only possible when the bot is granted a specific permission.
 /// </summary>
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = false)]
 public sealed class RequireBotPermissionsAttribute : CheckBaseAttribute
 {
 	/// <summary>
 	/// Gets the permissions required by this attribute.
 	/// </summary>
 	public Permissions Permissions { get; }
 
 	/// <summary>
 	/// Gets or sets this check's behaviour in DMs. True means the check will always pass in DMs, whereas false means that it will always fail.
 	/// </summary>
 	public bool IgnoreDms { get; } = true;
 
 	/// <summary>
 	/// Defines that usage of this command is only possible when the bot is granted a specific permission.
 	/// </summary>
 	/// <param name="permissions">Permissions required to execute this command.</param>
 	/// <param name="ignoreDms">Sets this check's behaviour in DMs. True means the check will always pass in DMs, whereas false means that it will always fail.</param>
 	public RequireBotPermissionsAttribute(Permissions permissions, bool ignoreDms = true)
 	{
 		this.Permissions = permissions;
 		this.IgnoreDms = ignoreDms;
 	}
 
 	/// <summary>
 	/// Executes the a check.
 	/// </summary>
 	/// <param name="ctx">The command context.</param>
 	/// <param name="help">If true, help - returns true.</param>
 	public override async Task<bool> ExecuteCheckAsync(CommandContext ctx, bool help)
 	{
 		if (ctx.Guild == null)
 			return this.IgnoreDms;
 
 		var bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id).ConfigureAwait(false);
 		if (bot == null)
 			return false;
 
 		if (bot.Id == ctx.Guild.OwnerId)
 			return true;
 
-		var pbot = ctx.Channel.PermissionsFor(bot);
+		var channel = ctx.Channel;
+		if (ctx.Channel.GuildId == null)
+		{
+			channel = await ctx.Client.GetChannelAsync(ctx.Channel.Id, true);
+		}
+		var pbot = channel.PermissionsFor(bot);
 
 		return (pbot & Permissions.Administrator) != 0 || (pbot & this.Permissions) == this.Permissions;
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Attributes/RequirePermissionsAttribute.cs b/DisCatSharp.CommandsNext/Attributes/RequirePermissionsAttribute.cs
index 9362133f6..c3ee201a2 100644
--- a/DisCatSharp.CommandsNext/Attributes/RequirePermissionsAttribute.cs
+++ b/DisCatSharp.CommandsNext/Attributes/RequirePermissionsAttribute.cs
@@ -1,88 +1,94 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Enums;
 
 namespace DisCatSharp.CommandsNext.Attributes;
 
 /// <summary>
 /// Defines that usage of this command is restricted to members with specified permissions. This check also verifies that the bot has the same permissions.
 /// </summary>
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = false)]
 public sealed class RequirePermissionsAttribute : CheckBaseAttribute
 {
 	/// <summary>
 	/// Gets the permissions required by this attribute.
 	/// </summary>
 	public Permissions Permissions { get; }
 
 	/// <summary>
 	/// Gets or sets this check's behaviour in DMs. True means the check will always pass in DMs, whereas false means that it will always fail.
 	/// </summary>
 	public bool IgnoreDms { get; } = true;
 
 	/// <summary>
 	/// Defines that usage of this command is restricted to members with specified permissions. This check also verifies that the bot has the same permissions.
 	/// </summary>
 	/// <param name="permissions">Permissions required to execute this command.</param>
 	/// <param name="ignoreDms">Sets this check's behaviour in DMs. True means the check will always pass in DMs, whereas false means that it will always fail.</param>
 	public RequirePermissionsAttribute(Permissions permissions, bool ignoreDms = true)
 	{
 		this.Permissions = permissions;
 		this.IgnoreDms = ignoreDms;
 	}
 
 	/// <summary>
 	/// Executes the a check.
 	/// </summary>
 	/// <param name="ctx">The command context.</param>
 	/// <param name="help">If true, help - returns true.</param>
 	public override async Task<bool> ExecuteCheckAsync(CommandContext ctx, bool help)
 	{
 		if (ctx.Guild == null)
 			return this.IgnoreDms;
 
+		var channel = ctx.Channel;
+		if (ctx.Channel.GuildId == null)
+		{
+			channel = await ctx.Client.GetChannelAsync(ctx.Channel.Id, true);
+		}
+
 		var usr = ctx.Member;
 		if (usr == null)
 			return false;
-		var pusr = ctx.Channel.PermissionsFor(usr);
+		var pusr = channel.PermissionsFor(usr);
 
 		var bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id).ConfigureAwait(false);
 		if (bot == null)
 			return false;
-		var pbot = ctx.Channel.PermissionsFor(bot);
+		var pbot = channel.PermissionsFor(bot);
 
 		var usrok = ctx.Guild.OwnerId == usr.Id;
 		var botok = ctx.Guild.OwnerId == bot.Id;
 
 		if (!usrok)
 			usrok = (pusr & Permissions.Administrator) != 0 || (pusr & this.Permissions) == this.Permissions;
 
 		if (!botok)
 			botok = (pbot & Permissions.Administrator) != 0 || (pbot & this.Permissions) == this.Permissions;
 
 		return usrok && botok;
 	}
 }
diff --git a/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs b/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs
index 3fa4d24cf..63ade7030 100644
--- a/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs
+++ b/DisCatSharp.CommandsNext/EventArgs/CommandContext.cs
@@ -1,207 +1,207 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Entities;
 
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.CommandsNext;
 
 /// <summary>
 /// Represents a context in which a command is executed.
 /// </summary>
 public sealed class CommandContext
 {
 	/// <summary>
 	/// Gets the client which received the message.
 	/// </summary>
 	public DiscordClient Client { get; internal set; }
 
 	/// <summary>
 	/// Gets the message that triggered the execution.
 	/// </summary>
 	public DiscordMessage Message { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel in which the execution was triggered,
 	/// </summary>
 	public DiscordChannel Channel
 		=> this.Message.Channel;
 
 	/// <summary>
 	/// Gets the guild in which the execution was triggered. This property is null for commands sent over direct messages.
 	/// </summary>
 	public DiscordGuild Guild
-		=> this.Channel.Guild;
+		=> this.Message.GuildId.HasValue ? this.Message.Guild : null;
 
 	/// <summary>
 	/// Gets the user who triggered the execution.
 	/// </summary>
 	public DiscordUser User
 		=> this.Message.Author;
 
 	/// <summary>
 	/// Gets the member who triggered the execution. This property is null for commands sent over direct messages.
 	/// </summary>
 	public DiscordMember Member
 		=> this._lazyMember.Value;
 
 	private readonly Lazy<DiscordMember> _lazyMember;
 
 	/// <summary>
 	/// Gets the CommandsNext service instance that handled this command.
 	/// </summary>
 	public CommandsNextExtension CommandsNext { get; internal set; }
 
 	/// <summary>
 	/// Gets the service provider for this CNext instance.
 	/// </summary>
 	public IServiceProvider Services { get; internal set; }
 
 	/// <summary>
 	/// Gets the command that is being executed.
 	/// </summary>
 	public Command Command { get; internal set; }
 
 	/// <summary>
 	/// Gets the overload of the command that is being executed.
 	/// </summary>
 	public CommandOverload Overload { get; internal set; }
 
 	/// <summary>
 	/// Gets the list of raw arguments passed to the command.
 	/// </summary>
 	public IReadOnlyList<string> RawArguments { get; internal set; }
 
 	/// <summary>
 	/// Gets the raw string from which the arguments were extracted.
 	/// </summary>
 	public string RawArgumentString { get; internal set; }
 
 	/// <summary>
 	/// Gets the prefix used to invoke the command.
 	/// </summary>
 	public string Prefix { get; internal set; }
 
 	/// <summary>
 	/// Gets or sets the config.
 	/// </summary>
 	internal CommandsNextConfiguration Config { get; set; }
 
 	/// <summary>
 	/// Gets or sets the service scope context.
 	/// </summary>
 	internal ServiceContext ServiceScopeContext { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="CommandContext"/> class.
 	/// </summary>
 	internal CommandContext()
 	{
 		this._lazyMember = new Lazy<DiscordMember>(() => this.Guild != null && this.Guild.Members.TryGetValue(this.User.Id, out var member) ? member : this.Guild?.GetMemberAsync(this.User.Id).ConfigureAwait(false).GetAwaiter().GetResult());
 	}
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="content">Message to respond with.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(string content)
 		=> this.Message.RespondAsync(content);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="embed">Embed to attach.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
 		=> this.Message.RespondAsync(embed);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="content">Message to respond with.</param>
 	/// <param name="embed">Embed to attach.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
 		=> this.Message.RespondAsync(content, embed);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="builder">The Discord Message builder.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
 		=> this.Message.RespondAsync(builder);
 
 	/// <summary>
 	/// Quickly respond to the message that triggered the command.
 	/// </summary>
 	/// <param name="action">The Discord Message builder.</param>
 	/// <returns></returns>
 	public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
 		=> this.Message.RespondAsync(action);
 
 	/// <summary>
 	/// Triggers typing in the channel containing the message that triggered the command.
 	/// </summary>
 	/// <returns></returns>
 	public Task TriggerTypingAsync()
 		=> this.Channel.TriggerTypingAsync();
 
 	internal readonly struct ServiceContext : IDisposable
 	{
 		/// <summary>
 		/// Gets the provider.
 		/// </summary>
 		public IServiceProvider Provider { get; }
 		/// <summary>
 		/// Gets the scope.
 		/// </summary>
 		public IServiceScope Scope { get; }
 		/// <summary>
 		/// Gets a value indicating whether is initialized.
 		/// </summary>
 		public bool IsInitialized { get; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ServiceContext"/> class.
 		/// </summary>
 		/// <param name="services">The services.</param>
 		/// <param name="scope">The scope.</param>
 		public ServiceContext(IServiceProvider services, IServiceScope scope)
 		{
 			this.Provider = services;
 			this.Scope = scope;
 			this.IsInitialized = true;
 		}
 
 		/// <summary>
 		/// Disposes the command context.
 		/// </summary>
 		public void Dispose() => this.Scope?.Dispose();
 	}
 }
diff --git a/DisCatSharp/Clients/DiscordClient.cs b/DisCatSharp/Clients/DiscordClient.cs
index a257d5a3a..097b3fac5 100644
--- a/DisCatSharp/Clients/DiscordClient.cs
+++ b/DisCatSharp/Clients/DiscordClient.cs
@@ -1,1587 +1,1591 @@
 // 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._automodRuleCreated = new AsyncEvent<DiscordClient, AutomodRuleCreateEventArgs>("AUTO_MODERATION_RULE_CREATED", EventExecutionLimit, this.EventErrorHandler); ;
 		this._automodRuleUpdated = new AsyncEvent<DiscordClient, AutomodRuleUpdateEventArgs>("AUTO_MODERATION_RULE_UPDATED", EventExecutionLimit, this.EventErrorHandler); ;
 		this._automodRuleDeleted = new AsyncEvent<DiscordClient, AutomodRuleDeleteEventArgs>("AUTO_MODERATION_RULE_DELETED", EventExecutionLimit, this.EventErrorHandler); ;
 		this._automodActionExecuted = new AsyncEvent<DiscordClient, AutomodActionExecutedEventArgs>("AUTO_MODERATION_ACTION_EXECUTED", 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="UnauthorizedException">Thrown when an invalid token was provided.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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 = true)
 		=> 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 ignore the cache. Defaults to false.</param>
 	/// <returns>The requested user.</returns>
 	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordUser> GetUserAsync(ulong userId, bool fetch = false)
 	{
 		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.AvatarDecorationHash = usr.AvatarDecorationHash;
 				old.ThemeColorsInternal = usr.ThemeColorsInternal;
 				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 
 			return usr;
 		}
 	}
 
 	/// <summary>
 	/// Gets a applications rpc information.
 	/// </summary>
 	/// <param name="applicationId">Id of the application</param>
 	/// <returns>The requested application.</returns>
 	/// <exception cref="NotFoundException">Thrown when the application does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordRpcApplication> GetRpcApplicationAsync(ulong applicationId)
 		=> await this.ApiClient.GetApplicationInfoAsync(applicationId);
 
 	/// <summary>
 	/// Tries to get a user.
 	/// </summary>
 	/// <param name="userId">Id of the user.</param>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to true.</param>
 	/// <returns>The requested user or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordUser?> TryGetUserAsync(ulong userId, bool fetch = true)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetUserAsync(userId, fetch).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets the applications role connection metadata.
 	/// </summary>
 	/// <returns>A list of metadata records or <see langword="null"/>.</returns>
 	public async Task<IReadOnlyList<DiscordApplicationRoleConnectionMetadata>> GetRoleConnectionMetadata()
 		 => await this.ApiClient.GetRoleConnectionMetadataRecords(this.CurrentApplication.Id);
 
 	/// <summary>
 	/// Updates the applications role connection metadata.
 	/// </summary>
 	/// <param name="metadata">A list of metadata objects. Max 5.</param>
 	public async Task<IReadOnlyList<DiscordApplicationRoleConnectionMetadata>> UpdateRoleConnectionMetadata(IEnumerable<DiscordApplicationRoleConnectionMetadata> metadata)
 		 => await this.ApiClient.UpdateRoleConnectionMetadataRecords(this.CurrentApplication.Id, metadata);
 
 	/// <summary>
 	/// Removes all global application commands.
 	/// </summary>
 	public async Task RemoveGlobalApplicationCommandsAsync()
 		=> await this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, Array.Empty<DiscordApplicationCommand>());
 
 	/// <summary>
 	/// Removes all global application commands for a specific guild id.
 	/// </summary>
 	/// <param name="guildId">The target guild id.</param>
 	public async Task RemoveGuildApplicationCommandsAsync(ulong guildId)
 		=> await this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, Array.Empty<DiscordApplicationCommand>());
 
 	/// <summary>
 	/// Removes all global application commands for a specific guild.
 	/// </summary>
 	/// <param name="guild">The target guild.</param>
 	public async Task RemoveGuildApplicationCommandsAsync(DiscordGuild guild)
 		=> await this.RemoveGuildApplicationCommandsAsync(guild.Id);
 
 	/// <summary>
 	/// Gets a channel.
 	/// </summary>
 	/// <param name="id">The id of the channel to get.</param>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to false.</param>
 	/// <returns>The requested channel.</returns>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> GetChannelAsync(ulong id, bool fetch = false)
 		=> (fetch ? null : this.InternalGetCachedChannel(id)) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Tries to get a channel.
 	/// </summary>
 	/// <param name="id">The id of the channel to get.</param>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to true.</param>
 	/// <returns>The requested channel or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordChannel?> TryGetChannelAsync(ulong id, bool fetch = true)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetChannelAsync(id, fetch).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets a thread.
 	/// </summary>
 	/// <param name="id">The id of the thread to get.</param>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to false.</param>
 	/// <returns>The requested thread.</returns>
 	/// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadChannel> GetThreadAsync(ulong id, bool fetch = false)
 		=> (fetch ? null : this.InternalGetCachedThread(id)) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Tries to get a thread.
 	/// </summary>
 	/// <param name="id">The id of the thread to get.</param>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to true.</param>
 	/// <returns>The requested thread or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordThreadChannel?> TryGetThreadAsync(ulong id, bool fetch = true)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetThreadAsync(id, fetch).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordMessageBuilder builder)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
 	/// <summary>
 	/// Sends a message with an <see cref="Action{DiscordMessageBuilder}"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="action">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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>
 	/// 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>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to false.</param>
 	/// <returns>The requested Guild.</returns>
 	/// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null, bool fetch = false)
 	{
 		if (!fetch && 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>
 	/// Tries to get 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>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to true.</param>
 	/// <returns>The requested Guild or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordGuild?> TryGetGuildAsync(ulong id, bool? withCounts = null, bool fetch = true)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetGuildAsync(id, withCounts, fetch).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets a guild preview.
 	/// </summary>
 	/// <param name="id">The guild ID.</param>
 	/// <returns>A preview of the requested guild.</returns>
 	/// <exception cref="NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
 		=> this.ApiClient.GetGuildPreviewAsync(id);
 
 	/// <summary>
 	/// Tries to get a guild preview.
 	/// </summary>
 	/// <param name="id">The guild ID.</param>
 	/// <returns>A preview of the requested guild or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordGuildPreview?> TryGetGuildPreviewAsync(ulong id)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.ApiClient.GetGuildPreviewAsync(id).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets a guild widget.
 	/// </summary>
 	/// <param name="id">The Guild Id.</param>
 	/// <returns>A guild widget.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWidget> GetGuildWidgetAsync(ulong id)
 		=> this.ApiClient.GetGuildWidgetAsync(id);
 
 	/// <summary>
 	/// Tries to get a guild widget.
 	/// </summary>
 	/// <param name="id">The Guild Id.</param>
 	/// <returns>The requested guild widget or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordWidget?> TryGetGuildWidgetAsync(ulong id)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.ApiClient.GetGuildWidgetAsync(id);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets an invite.
 	/// </summary>
 	/// <param name="code">The invite code.</param>
 	/// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
 	/// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
 	/// <param name="scheduledEventId">The scheduled event id.</param>
 	/// <returns>The requested invite.</returns>
 	/// <exception cref="NotFoundException">Thrown when the invite does not exists.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 		=> this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
 	/// <summary>
 	/// Tries to get 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 or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordInvite?> TryGetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetInviteByCodeAsync(code, withCounts, withExpiration, scheduledEventId).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets a list of user connections.
 	/// </summary>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordConnection>> GetConnectionsAsync()
 		=> this.ApiClient.GetUserConnectionsAsync();
 
 	/// <summary>
 	/// Gets a sticker.
 	/// </summary>
 	/// <returns>The requested sticker.</returns>
 	/// <param name="id">The id of the sticker.</param>
 	/// <exception cref="NotFoundException">Thrown when the sticker does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordSticker> GetStickerAsync(ulong id)
 		=> this.ApiClient.GetStickerAsync(id);
 
 	/// <summary>
 	/// Tries to get a sticker.
 	/// </summary>
 	/// <returns>The requested sticker or null if not found.</returns>
 	/// <param name="id">The id of the sticker.</param>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordSticker?> TryGetStickerAsync(ulong id)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetStickerAsync(id).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets all nitro sticker packs.
 	/// </summary>
 	/// <returns>List of sticker packs.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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;
 		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>
 	/// Generates an In-App OAuth Url.
 	/// </summary>
 	/// <param name="bot">The bot to generate the url for.</param>
 	/// <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 GenerateInAppOauthFor(DiscordUser bot, Permissions permissions = Permissions.None, OAuthScopes scopes = OAuthScopes.BOT_DEFAULT, string redir = null)
 	{
 		if (!bot.IsBot)
 			throw new ArgumentException("The user must be a bot.", nameof(bot));
 		permissions &= PermissionMethods.FullPerms;
 		return new Uri(new QueryUriBuilder($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.OAUTH2}{Endpoints.AUTHORIZE}")
 			.AddParameter("client_id", bot.Id.ToString(CultureInfo.InvariantCulture))
 			.AddParameter("scope", OAuth.ResolveScopes(scopes))
 			.AddParameter("permissions", ((long)permissions).ToString(CultureInfo.InvariantCulture))
 			.AddParameter("state", "")
 			.AddParameter("redirect_uri", redir ?? "")
 			.ToString());
 	}
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <returns>The requested webhook.</returns>
 	/// <exception cref="NotFoundException">Thrown when the webhook does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWebhook> GetWebhookAsync(ulong id)
 		=> this.ApiClient.GetWebhookAsync(id);
 
 	/// <summary>
 	/// Tries to get a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <returns>The requested webhook or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordWebhook?> TryGetWebhookAsync(ulong id)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetWebhookAsync(id).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Gets a webhook with a token.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <param name="token">The target webhook token.</param>
 	/// <returns>The requested webhook.</returns>
 	/// <exception cref="NotFoundException">Thrown when the webhook does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
 		=> this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
 	/// <summary>
 	/// Tries to get a webhook with a token.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <param name="token">The target webhook token.</param>
 	/// <returns>The requested webhook or null if not found.</returns>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordWebhook?> TryGetWebhookWithTokenAsync(ulong id, string token)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	{
 		try
 		{
 			return await this.GetWebhookWithTokenAsync(id, token).ConfigureAwait(false);
 		}
 		catch (NotFoundException)
 		{
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Updates current user's activity and status.
 	/// </summary>
 	/// <param name="activity">Activity to set.</param>
 	/// <param name="userStatus">Status of the user.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 	/// <returns></returns>
 	public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 		=> this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
 	/// <summary>
 	/// Edits current user.
 	/// </summary>
 	/// <param name="username">New username.</param>
 	/// <param name="avatar">New avatar.</param>
 	/// <returns>The modified user.</returns>
 	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	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="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="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)
 	{
 		if (this.Guilds == null)
 			return null;
 
 		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)
 	{
 		if (this.Guilds == null)
 			return null;
 
 		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>
 	/// <returns>The requested channel.</returns>
-	internal DiscordChannel InternalGetCachedChannel(ulong channelId)
+	internal DiscordChannel InternalGetCachedChannel(ulong channelId, ulong? guildId = null)
 	{
 		if (this.Guilds == null)
 			return null;
 
 		foreach (var guild in this.Guilds.Values)
 			if (guild.Channels.TryGetValue(channelId, out var foundChannel))
+			{
+				if (guildId.HasValue)
+					foundChannel.GuildId = guildId;
 				return foundChannel;
+			}
 
 		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.AvatarDecorationHash = usr.AvatarDecorationHash;
 					old.ThemeColorsInternal = usr.ThemeColorsInternal;
 					old.Pronouns = usr.Pronouns;
 					old.Locale = usr.Locale;
 					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.AvatarDecorationHash = usr.AvatarDecorationHash;
 				old.ThemeColorsInternal = usr.ThemeColorsInternal;
 				old.Pronouns = usr.Pronouns;
 				old.Locale = usr.Locale;
 				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;
 
 				channel.Initialize(this);
 
 				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);
 
 		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/Entities/Message/DiscordMessage.cs b/DisCatSharp/Entities/Message/DiscordMessage.cs
index fb7d8ca02..c31fcf48f 100644
--- a/DisCatSharp/Entities/Message/DiscordMessage.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessage.cs
@@ -1,1072 +1,1083 @@
 // 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 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.GuildId.HasValue
+					? this.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);
 
 		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.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;
+		this.GuildId = other.GuildId;
 	}
 
 	/// <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;
+		get => (this.Discord as DiscordClient)?.InternalGetCachedChannel(this.ChannelId, this.GuildId) ?? 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
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedThread(this.ChannelId) ?? this._thread;
 		set => this._thread = value;
 	}
 
 	private DiscordThreadChannel _thread;
 
 	/// <summary>
 	/// Gets the ID of the channel in which the message was sent.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the components this message was sent with.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordActionRowComponent> Components { get; internal set; }
 
 	/// <summary>
 	/// Gets the user or member that sent the message.
 	/// </summary>
 	[JsonProperty("author", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser Author { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's creation timestamp.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset Timestamp
 		=> !string.IsNullOrWhiteSpace(this.TimestampRaw) && DateTimeOffset.TryParse(this.TimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : this.CreationTimestamp;
 
 	/// <summary>
 	/// Gets the message's creation timestamp as raw string.
 	/// </summary>
 	[JsonProperty("timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string TimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the message's edit timestamp. Will be null if the message was not edited.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? EditedTimestamp
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw) && DateTimeOffset.TryParse(this.EditedTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets the message's edit timestamp as raw string. Will be null if the message was not edited.
 	/// </summary>
 	[JsonProperty("edited_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string EditedTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets whether this message was edited.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsEdited
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw);
 
 	/// <summary>
 	/// Gets whether the message is a text-to-speech message.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsTts { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message mentions everyone.
 	/// </summary>
 	[JsonProperty("mention_everyone", NullValueHandling = NullValueHandling.Ignore)]
 	public bool MentionEveryone { get; internal set; }
 
 	/// <summary>
 	/// Gets users or members mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordUser> MentionedUsers
 		=> this.MentionedUsersLazy.Value;
 
 	[JsonProperty("mentions", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordUser> MentionedUsersInternal;
 	[JsonIgnore]
 	internal readonly Lazy<IReadOnlyList<DiscordUser>> MentionedUsersLazy;
 
 	// TODO: this will probably throw an exception in DMs since it tries to wrap around a null List...
 	// this is probably low priority but need to find out a clean way to solve it...
 	/// <summary>
 	/// Gets roles mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordRole> MentionedRoles
 		=> this._mentionedRolesLazy.Value;
 
 	[JsonIgnore]
 	internal List<DiscordRole> MentionedRolesInternal;
 
 	[JsonProperty("mention_roles")]
 	internal List<ulong> MentionedRoleIds;
 
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordRole>> _mentionedRolesLazy;
 
 	/// <summary>
 	/// Gets channels mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordChannel> MentionedChannels
 		=> this._mentionedChannelsLazy.Value;
 
 	[JsonIgnore]
 	internal List<DiscordChannel> MentionedChannelsInternal;
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordChannel>> _mentionedChannelsLazy;
 
 	/// <summary>
 	/// Gets files attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordAttachment> Attachments
 		=> this._attachmentsLazy.Value;
 
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordAttachment> 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;
 
 	[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)]
 	public ulong? GuildId { get; internal set; }
 
+	/// <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 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))
 			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))
 			mentions.Add(new RepliedUserMention());
 
 		if (this.MentionedUsersInternal.Any())
 			mentions.AddRange(this.MentionedUsersInternal.Select(m => (IMention)new UserMention(m)));
 
 		if (this.MentionedRoleIds.Any())
 			mentions.AddRange(this.MentionedRoleIds.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>();
 
 		var mentionedUsers = new HashSet<DiscordUser>(new DiscordUserComparer());
 		if (guild != null)
 		{
 			foreach (var usr in this.MentionedUsersInternal)
 			{
 				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();
 	}
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="embed">New embed.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<DiscordEmbed> embed = default)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> 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);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embed">New embed.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<DiscordEmbed> embed = default)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> 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);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embeds">New embeds.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds = default)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="builder">The builder of the message to edit.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> ModifyAsync(DiscordMessageBuilder builder)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 	{
 		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);
 	}
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message embed suppression.
 	/// </summary>
 	/// <param name="suppress">Suppress embeds.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifySuppressionAsync(bool suppress = false)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> 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>());
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="action">The builder of the message to edit.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> ModifyAsync(Action<DiscordMessageBuilder> action)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 	{
 		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);
 	}
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Deletes the message.
 	/// </summary>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.ChannelId, this.Id, reason);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="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, isForum: false, reason: reason)
 			: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Pins the message in its channel.
 	/// </summary>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task PinAsync()
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.PinMessageAsync(this.ChannelId, this.Id);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Unpins the message in its channel.
 	/// </summary>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnpinAsync()
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.UnpinMessageAsync(this.ChannelId, this.Id);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(string content)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		return this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 	}
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task CreateReactionAsync(DiscordEmoji emoji)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.CreateReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOwnReactionAsync(DiscordEmoji emoji)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.DeleteOwnReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteReactionAsync(DiscordEmoji emoji, DiscordUser user, string reason = null)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.DeleteUserReactionAsync(this.ChannelId, this.Id, user.Id, emoji.ToReactionString(), reason);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.GetReactionsInternalAsync(emoji, limit, after);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <summary>
 	/// Deletes all reactions for this message.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAllReactionsAsync(string reason = null)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> this.Discord.ApiClient.DeleteAllReactionsAsync(this.ChannelId, this.Id, reason);
 
 	
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning disable CS1574 // XML comment has cref attribute that could not be resolved
 /// <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="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteReactionsEmojiAsync(DiscordEmoji emoji)
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 #pragma warning restore CS1574 // XML comment has cref attribute that could not be resolved
 		=> 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/EventArgs/Message/MessageCreateEventArgs.cs b/DisCatSharp/EventArgs/Message/MessageCreateEventArgs.cs
index 3f2ff2793..07e5d5e91 100644
--- a/DisCatSharp/EventArgs/Message/MessageCreateEventArgs.cs
+++ b/DisCatSharp/EventArgs/Message/MessageCreateEventArgs.cs
@@ -1,83 +1,83 @@
 // 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.Entities;
 
 namespace DisCatSharp.EventArgs;
 
 /// <summary>
 /// Represents arguments for <see cref="DiscordClient.MessageCreated"/> event.
 /// </summary>
 public class MessageCreateEventArgs : DiscordEventArgs
 {
 	/// <summary>
 	/// Gets the message that was created.
 	/// </summary>
 	public DiscordMessage Message { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel this message belongs to.
 	/// </summary>
 	public DiscordChannel Channel
 		=> this.Message.Channel;
 
 	/// <summary>
 	/// Gets the guild this message belongs to.
 	/// </summary>
 	public DiscordGuild Guild
-		=> this.Channel.Guild;
+		=> this.Message.Guild;
 
 	/// <summary>
 	/// Gets the guild id in case it couldn't convert.
 	/// </summary>
 	public ulong? GuildId
 		=> this.Message.GuildId;
 
 	/// <summary>
 	/// Gets the author of the message.
 	/// </summary>
 	public DiscordUser Author
 		=> this.Message.Author;
 
 	/// <summary>
 	/// Gets the collection of mentioned users.
 	/// </summary>
 	public IReadOnlyList<DiscordUser> MentionedUsers { get; internal set; }
 
 	/// <summary>
 	/// Gets the collection of mentioned roles.
 	/// </summary>
 	public IReadOnlyList<DiscordRole> MentionedRoles { get; internal set; }
 
 	/// <summary>
 	/// Gets the collection of mentioned channels.
 	/// </summary>
 	public IReadOnlyList<DiscordChannel> MentionedChannels { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="MessageCreateEventArgs"/> class.
 	/// </summary>
 	internal MessageCreateEventArgs(IServiceProvider provider) : base(provider) { }
 }