diff --git a/DisCatSharp/Entities/Guild/DiscordMember.cs b/DisCatSharp/Entities/Guild/DiscordMember.cs
index 4d4a59dbb..3a5096f26 100644
--- a/DisCatSharp/Entities/Guild/DiscordMember.cs
+++ b/DisCatSharp/Entities/Guild/DiscordMember.cs
@@ -1,807 +1,722 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord guild member.
 /// </summary>
 public class DiscordMember : DiscordUser, IEquatable<DiscordMember>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	internal DiscordMember()
 	{
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	/// <param name="user">The user.</param>
 	internal DiscordMember(DiscordUser user)
 	{
 		this.Discord = user.Discord;
 
 		this.Id = user.Id;
 
 		this.RoleIdsInternal = new List<ulong>();
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	/// <param name="mbr">The mbr.</param>
 	internal DiscordMember(TransportMember mbr)
 	{
 		this.Id = mbr.User.Id;
 		this.IsDeafened = mbr.IsDeafened;
 		this.IsMuted = mbr.IsMuted;
 		this.JoinedAt = mbr.JoinedAt;
 		this.Nickname = mbr.Nickname;
 		this.PremiumSince = mbr.PremiumSince;
 		this.IsPending = mbr.IsPending;
 		this.GuildAvatarHash = mbr.GuildAvatarHash;
 		this.GuildBannerHash = mbr.GuildBannerHash;
 		this.GuildBio = mbr.GuildBio;
 		this.GuildPronouns = mbr.GuildPronouns;
 		this.CommunicationDisabledUntil = mbr.CommunicationDisabledUntil;
 		this.AvatarHashInternal = mbr.AvatarHash;
 		this.RoleIdsInternal = mbr.Roles ?? new List<ulong>();
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 		this.MemberFlags = mbr.MemberFlags;
 	}
 
 	/// <summary>
 	/// Gets the members avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string GuildAvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the members avatar URL.
 	/// </summary>
 	[JsonIgnore]
 	public string GuildAvatarUrl
 		=> string.IsNullOrWhiteSpace(this.GuildAvatarHash) ? this.User.AvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this.GuildId.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.AVATARS}/{this.GuildAvatarHash}.{(this.GuildAvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the members banner hash.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string GuildBannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the members banner URL.
 	/// </summary>
 	[JsonIgnore]
 	public string GuildBannerUrl
 		=> string.IsNullOrWhiteSpace(this.GuildBannerHash) ? this.User.BannerUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this.GuildId.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.GuildBannerHash}.{(this.GuildBannerHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// The color of this member's banner. Mutually exclusive with <see cref="GuildBannerHash"/>.
 	/// </summary>
 	[JsonIgnore]
 	public override DiscordColor? BannerColor
 		=> this.User.BannerColor;
 
 	/// <summary>
 	/// Gets this member's nickname.
 	/// </summary>
 	[JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nickname { get; internal set; }
 
 	/// <summary>
 	/// Gets the members guild bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildBio { get; internal set; }
 
 	/// <summary>
 	/// Gets the members's pronouns.
 	/// </summary>
 	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildPronouns { get; internal set; }
 
 	/// <summary>
 	/// Gets the members flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MemberFlags MemberFlags { get; internal set; }
 
 	[JsonIgnore]
 	internal string AvatarHashInternal;
 
 	/// <summary>
 	/// Gets this member's display name.
 	/// </summary>
 	[JsonIgnore]
 	public string DisplayName
 		=> this.Nickname ?? this.Username;
 
 	/// <summary>
 	/// List of role ids
 	/// </summary>
 	[JsonIgnore]
 	internal IReadOnlyList<ulong> RoleIds
 		=> this._roleIdsLazy.Value;
 
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<ulong> RoleIdsInternal;
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<ulong>> _roleIdsLazy;
 
 	/// <summary>
 	/// Gets the list of roles associated with this member.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordRole> Roles
 		=> this.RoleIds.Select(id => this.Guild.GetRole(id)).Where(x => x != null).ToList();
 
 	/// <summary>
 	/// Gets the color associated with this user's top color-giving role, otherwise 0 (no color).
 	/// </summary>
 	[JsonIgnore]
 	public DiscordColor Color
 	{
 		get
 		{
 			var role = this.Roles.OrderByDescending(xr => xr.Position).FirstOrDefault(xr => xr.Color.Value != 0);
 			return role != null ? role.Color : new DiscordColor();
 		}
 	}
 
 	/// <summary>
 	/// Date the user joined the guild
 	/// </summary>
 	[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset JoinedAt { get; internal set; }
 
 	/// <summary>
 	/// Date the user started boosting this server
 	/// </summary>
 	[JsonProperty("premium_since", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset? PremiumSince { get; internal set; }
 
 	/// <summary>
 	/// Date until the can communicate again.
 	/// </summary>
 	[JsonProperty("communication_disabled_until", NullValueHandling = NullValueHandling.Include)]
 	public DateTime? CommunicationDisabledUntil { get; internal set; }
 
 	/// <summary>
 	/// If the user is deafened
 	/// </summary>
 	[JsonProperty("is_deafened", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsDeafened { get; internal set; }
 
 	/// <summary>
 	/// If the user is muted
 	/// </summary>
 	[JsonProperty("is_muted", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsMuted { get; internal set; }
 
 	/// <summary>
 	/// Whether the user has not passed the guild's Membership Screening requirements yet.
 	/// </summary>
 	[JsonProperty("pending", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsPending { get; internal set; }
 
 	/// <summary>
 	/// Gets this member's voice state.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceState VoiceState
 		=> this.Discord.Guilds[this.GuildId].VoiceStates.TryGetValue(this.Id, out var voiceState) ? voiceState : null;
 
 	[JsonIgnore]
 	internal ulong GuildId = 0;
 
 	/// <summary>
 	/// Gets the guild of which this member is a part of.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.Discord.Guilds[this.GuildId];
 
 	/// <summary>
 	/// Gets whether this member is the Guild owner.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsOwner
 		=> this.Id == this.Guild.OwnerId;
 
 	/// <summary>
 	/// Gets the member's position in the role hierarchy, which is the member's highest role's position. Returns <see cref="int.MaxValue"/> for the guild's owner.
 	/// </summary>
 	[JsonIgnore]
 	public int Hierarchy
 		=> this.IsOwner ? int.MaxValue : this.RoleIds.Count == 0 ? 0 : this.Roles.Max(x => x.Position);
 
 	/// <summary>
 	/// Gets the permissions for the current member.
 	/// </summary>
 	[JsonIgnore]
 	public Permissions Permissions
 		=> this.GetPermissions();
 
 	#region Overridden user properties
 
 	/// <summary>
 	/// Gets the user.
 	/// </summary>
 	[JsonIgnore]
 	internal DiscordUser User
 		=> this.Discord.UserCache[this.Id];
 
 	/// <summary>
 	/// Gets this member's username.
 	/// </summary>
 	[JsonIgnore]
 	public override string Username
 	{
 		get => this.User.Username;
 		internal set => this.User.Username = value;
 	}
 
 	/// <summary>
 	/// Gets the member's 4-digit discriminator.
 	/// </summary>
 	[JsonIgnore]
 	public override string Discriminator
 	{
 		get => this.User.Discriminator;
 		internal set => this.User.Discriminator = value;
 	}
 
 	/// <summary>
 	/// Gets the member's avatar hash.
 	/// </summary>
 	[JsonIgnore]
 	public override string AvatarHash
 	{
 		get => this.User.AvatarHash;
 		internal set => this.User.AvatarHash = value;
 	}
 
 	/// <summary>
 	/// Gets the member's banner hash.
 	/// </summary>
 	[JsonIgnore]
 	public override string BannerHash
 	{
 		get => this.User.BannerHash;
 		internal set => this.User.BannerHash = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member is a bot.
 	/// </summary>
 	[JsonIgnore]
 	public override bool IsBot
 	{
 		get => this.User.IsBot;
 		internal set => this.User.IsBot = value;
 	}
 
 	/// <summary>
 	/// Gets the member's email address.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonIgnore]
 	public override string Email
 	{
 		get => this.User.Email;
 		internal set => this.User.Email = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member has multi-factor authentication enabled.
 	/// </summary>
 	[JsonIgnore]
 	public override bool? MfaEnabled
 	{
 		get => this.User.MfaEnabled;
 		internal set => this.User.MfaEnabled = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member is verified.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonIgnore]
 	public override bool? Verified
 	{
 		get => this.User.Verified;
 		internal set => this.User.Verified = value;
 	}
 
 	/// <summary>
 	/// Gets the member's chosen language
 	/// </summary>
 	[JsonIgnore]
 	public override string Locale
 	{
 		get => this.User.Locale;
 		internal set => this.User.Locale = value;
 	}
 
 	/// <summary>
 	/// Gets the user's flags.
 	/// </summary>
 	[JsonIgnore]
 	public override UserFlags? OAuthFlags
 	{
 		get => this.User.OAuthFlags;
 		internal set => this.User.OAuthFlags = value;
 	}
 
 	/// <summary>
 	/// Gets the member's flags for OAuth.
 	/// </summary>
 	[JsonIgnore]
 	public override UserFlags? Flags
 	{
 		get => this.User.Flags;
 		internal set => this.User.Flags = value;
 	}
 
 	#endregion
 
-
-	/// <summary>
-	/// Creates a direct message channel to this member.
-	/// </summary>
-	/// <returns>Direct message channel to this member.</returns>
-	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="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<DiscordDmChannel> CreateDmChannelAsync()
-		=> this.Discord.ApiClient.CreateDmAsync(this.Id);
-
-	/// <summary>
-	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
-	/// </summary>
-	/// <param name="content">Content of the message to send.</param>
-	/// <returns>The sent message.</returns>
-	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="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> SendMessageAsync(string content)
-	{
-		if (this.IsBot && this.Discord.CurrentUser.IsBot)
-			throw new ArgumentException("Bots cannot DM each other.");
-
-		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
-		return await chn.SendMessageAsync(content).ConfigureAwait(false);
-	}
-
-	/// <summary>
-	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
-	/// </summary>
-	/// <param name="embed">Embed to attach to the message.</param>
-	/// <returns>The sent message.</returns>
-	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="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> SendMessageAsync(DiscordEmbed embed)
-	{
-		if (this.IsBot && this.Discord.CurrentUser.IsBot)
-			throw new ArgumentException("Bots cannot DM each other.");
-
-		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
-		return await chn.SendMessageAsync(embed).ConfigureAwait(false);
-	}
-
-	/// <summary>
-	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
-	/// </summary>
-	/// <param name="content">Content of the message to send.</param>
-	/// <param name="embed">Embed to attach to the message.</param>
-	/// <returns>The sent message.</returns>
-	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="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> SendMessageAsync(string content, DiscordEmbed embed)
-	{
-		if (this.IsBot && this.Discord.CurrentUser.IsBot)
-			throw new ArgumentException("Bots cannot DM each other.");
-
-		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
-		return await chn.SendMessageAsync(content, embed).ConfigureAwait(false);
-	}
-
-	/// <summary>
-	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
-	/// </summary>
-	/// <param name="message">Builder to with the message.</param>
-	/// <returns>The sent message.</returns>
-	/// <exception cref="UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
-	/// <exception cref="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> SendMessageAsync(DiscordMessageBuilder message)
-	{
-		if (this.IsBot && this.Discord.CurrentUser.IsBot)
-			throw new ArgumentException("Bots cannot DM each other.");
-
-		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
-		return await chn.SendMessageAsync(message).ConfigureAwait(false);
-	}
-
 	/// <summary>
 	/// Sets this member's voice mute status.
 	/// </summary>
 	/// <param name="mute">Whether the member is to be muted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> 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 SetMuteAsync(bool mute, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, mute, default, default, default, this.MemberFlags, reason);
 
 	public Task VerifyAsync(string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, default, default, default, true, this.MemberFlags, reason);
 
 	public Task UnverifyAsync(string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, default, default, default, false, this.MemberFlags, reason);
 
 	/// <summary>
 	/// Sets this member's voice deaf status.
 	/// </summary>
 	/// <param name="deaf">Whether the member is to be deafened.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.DeafenMembers"/> 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 SetDeafAsync(bool deaf, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, default, deaf, default, default, this.MemberFlags, reason);
 
 	/// <summary>
 	/// Modifies this member.
 	/// </summary>
 	/// <param name="action">Action to perform on this member.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageNicknames"/> 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 async Task ModifyAsync(Action<MemberEditModel> action)
 	{
 		var mdl = new MemberEditModel();
 		action(mdl);
 
 		if (mdl.VoiceChannel.HasValue && mdl.VoiceChannel.Value != null && mdl.VoiceChannel.Value.Type != ChannelType.Voice && mdl.VoiceChannel.Value.Type != ChannelType.Stage)
 			throw new ArgumentException("Given channel is not a voice or stage channel.", nameof(action));
 
 		if (mdl.Nickname.HasValue && this.Discord.CurrentUser.Id == this.Id)
 		{
 			await this.Discord.ApiClient.ModifyCurrentMemberNicknameAsync(this.Guild.Id, mdl.Nickname.Value,
 				mdl.AuditLogReason).ConfigureAwait(false);
 
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, Optional.None,
 				mdl.Roles.Map(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
 				mdl.VoiceChannel.Map(e => e?.Id), default, this.MemberFlags, mdl.AuditLogReason).ConfigureAwait(false);
 		}
 		else
 		{
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, mdl.Nickname,
 				mdl.Roles.Map(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
 				mdl.VoiceChannel.Map(e => e?.Id), default, this.MemberFlags, mdl.AuditLogReason).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Disconnects the member from their current voice channel.
 	/// </summary>
 	public async Task DisconnectFromVoiceAsync()
 		=> await this.ModifyAsync(x => x.VoiceChannel = null);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> 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 TimeoutAsync(DateTimeOffset until, string reason = null)
 		=> until.Subtract(DateTimeOffset.UtcNow).Days > 28 ? throw new ArgumentException("Timeout can not be longer than 28 days") : this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, until, reason);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The timespan to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> 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 TimeoutAsync(TimeSpan until, string reason = null)
 		=> this.TimeoutAsync(DateTimeOffset.UtcNow + until, reason);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The datetime to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> 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 TimeoutAsync(DateTime until, string reason = null)
 		=> this.TimeoutAsync(until.ToUniversalTime() - DateTime.UtcNow, reason);
 
 	/// <summary>
 	/// Removes the timeout from a member.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> 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 RemoveTimeoutAsync(string reason = null)
 		=> this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, null, reason);
 
 	/// <summary>
 	/// Grants a role to the member.
 	/// </summary>
 	/// <param name="role">Role to grant.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 GrantRoleAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.AddGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Revokes a role from a member.
 	/// </summary>
 	/// <param name="role">Role to revoke.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 RevokeRoleAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Sets the member's roles to ones specified.
 	/// </summary>
 	/// <param name="roles">Roles to set.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 ReplaceRolesAsync(IEnumerable<DiscordRole> roles, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, default,
 			Optional.Some(roles.Select(xr => xr.Id)), default, default, default, default, this.MemberFlags, reason);
 
 	/// <summary>
 	/// Bans this member from their guild.
 	/// </summary>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task BanAsync(int deleteMessageDays = 0, string reason = null)
 		=> this.Guild.BanMemberAsync(this, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Unbans this member from their guild.
 	/// </summary>
 	/// <exception cref = "Exceptions.UnauthorizedException" > Thrown when the client does not have the<see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="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 UnbanAsync(string reason = null)
 		=> this.Guild.UnbanMemberAsync(this, reason);
 
 	/// <summary>
 	/// Kicks this member from their guild.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns></returns>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> 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 RemoveAsync(string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildMemberAsync(this.GuildId, this.Id, reason);
 
 	/// <summary>
 	/// Moves this member to the specified voice channel
 	/// </summary>
 	/// <param name="channel"></param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> 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 PlaceInAsync(DiscordChannel channel)
 		=> channel.PlaceMemberAsync(this);
 
 	/// <summary>
 	/// Updates the member's suppress state in a stage channel.
 	/// </summary>
 	/// <param name="channel">The channel the member is currently in.</param>
 	/// <param name="suppress">Toggles the member's suppress state.</param>
 	/// <exception cref="ArgumentException">Thrown when the channel in not a voice channel.</exception>
 	public async Task UpdateVoiceStateAsync(DiscordChannel channel, bool? suppress)
 	{
 		if (channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, channel.Id, suppress).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Makes the user a speaker.
 	/// </summary>
 	/// <exception cref="ArgumentException">Thrown when the user is not inside an stage channel.</exception>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> 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 async Task MakeSpeakerAsync()
 	{
 		var vs = this.VoiceState;
 		if (vs == null || vs.Channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, false).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Moves the user to audience.
 	/// </summary>
 	/// <exception cref="ArgumentException">Thrown when the user is not inside an stage channel.</exception>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> 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 async Task MoveToAudienceAsync()
 	{
 		var vs = this.VoiceState;
 		if (vs == null || vs.Channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, true).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Calculates permissions in a given channel for this member.
 	/// </summary>
 	/// <param name="channel">Channel to calculate permissions for.</param>
 	/// <returns>Calculated permissions for this member in the channel.</returns>
 	public Permissions PermissionsIn(DiscordChannel channel)
 		=> channel.PermissionsFor(this);
 
 	/// <summary>
 	/// Get's the current member's roles based on the sum of the permissions of their given roles.
 	/// </summary>
 	private Permissions GetPermissions()
 	{
 		if (this.Guild.OwnerId == this.Id)
 			return PermissionMethods.FullPerms;
 
 		Permissions perms;
 
 		// assign @everyone permissions
 		var everyoneRole = this.Guild.EveryoneRole;
 		perms = everyoneRole.Permissions;
 
 		// assign permissions from member's roles (in order)
 		perms |= this.Roles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
 		// Administrator grants all permissions and cannot be overridden
 		return (perms & Permissions.Administrator) == Permissions.Administrator ? PermissionMethods.FullPerms : perms;
 	}
 
 	/// <summary>
 	/// Returns a string representation of this member.
 	/// </summary>
 	/// <returns>String representation of this member.</returns>
 	public override string ToString()
 		=> $"Member {this.Id}; {this.Username}#{this.Discriminator} ({this.DisplayName})";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMember"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordMember"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordMember);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMember"/> is equal to another <see cref="DiscordMember"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordMember"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordMember"/> is equal to this <see cref="DiscordMember"/>.</returns>
 	public bool Equals(DiscordMember e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.GuildId == e.GuildId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordMember"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordMember"/>.</returns>
 	public override int GetHashCode()
 	{
 		var hash = 13;
 
 		hash = (hash * 7) + this.Id.GetHashCode();
 		hash = (hash * 7) + this.GuildId.GetHashCode();
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMember"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First member to compare.</param>
 	/// <param name="e2">Second member to compare.</param>
 	/// <returns>Whether the two members are equal.</returns>
 	public static bool operator ==(DiscordMember e1, DiscordMember e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.GuildId == e2.GuildId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMember"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First member to compare.</param>
 	/// <param name="e2">Second member to compare.</param>
 	/// <returns>Whether the two members are not equal.</returns>
 	public static bool operator !=(DiscordMember e1, DiscordMember e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/User/DiscordUser.cs b/DisCatSharp/Entities/User/DiscordUser.cs
index 13b69e8d7..3510dbacf 100644
--- a/DisCatSharp/Entities/User/DiscordUser.cs
+++ b/DisCatSharp/Entities/User/DiscordUser.cs
@@ -1,523 +1,607 @@
 // 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.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord user.
 /// </summary>
 public class DiscordUser : SnowflakeObject, IEquatable<DiscordUser>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 	/// </summary>
 	internal DiscordUser()
 	{ }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 	/// </summary>
 	/// <param name="transport">The transport user.</param>
 	internal DiscordUser(TransportUser transport)
 	{
 		this.Id = transport.Id;
 		this.Username = transport.Username;
 		this.Discriminator = transport.Discriminator;
 		this.AvatarHash = transport.AvatarHash;
 		this.AvatarDecorationHash = transport.AvatarDecorationHash;
 		this.BannerHash = transport.BannerHash;
 		this.BannerColorInternal = transport.BannerColor;
 		this.ThemeColorsInternal = (transport.ThemeColors ?? Array.Empty<int>()).ToList();
 		this.IsBot = transport.IsBot;
 		this.MfaEnabled = transport.MfaEnabled;
 		this.Verified = transport.Verified;
 		this.Email = transport.Email;
 		this.PremiumType = transport.PremiumType;
 		this.Locale = transport.Locale;
 		this.Flags = transport.Flags;
 		this.OAuthFlags = transport.OAuthFlags;
 		this.Bio = transport.Bio;
 		this.Pronouns = transport.Pronouns;
 	}
 
 	/// <summary>
 	/// Gets this user's username.
 	/// </summary>
 	[JsonProperty("username", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Username { get; internal set; }
 
 	/// <summary>
 	/// Gets this user's username with the discriminator.
 	/// Example: Discord#0000
 	/// </summary>
 	[JsonIgnore]
 	public virtual string UsernameWithDiscriminator
 		=> $"{this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Gets the user's 4-digit discriminator.
 	/// </summary>
 	[JsonProperty("discriminator", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Discriminator { get; internal set; }
 
 	/// <summary>
 	/// Gets the discriminator integer.
 	/// </summary>
 	[JsonIgnore]
 	internal int DiscriminatorInt
 		=> int.Parse(this.Discriminator, NumberStyles.Integer, CultureInfo.InvariantCulture);
 
 	/// <summary>
 	/// Gets the user's banner color, if set. Mutually exclusive with <see cref="BannerHash"/>.
 	/// </summary>
 	[JsonIgnore]
 	public virtual DiscordColor? BannerColor
 		=> !this.BannerColorInternal.HasValue ? null : new DiscordColor(this.BannerColorInternal.Value);
 
 	/// <summary>
 	/// Gets the user's theme colors, if set.
 	/// </summary>
 	[JsonIgnore]
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public virtual IReadOnlyList<DiscordColor>? ThemeColors
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 		=> !(this.ThemeColorsInternal is not null && this.ThemeColorsInternal.Count != 0) ? null : this.ThemeColorsInternal.Select(x => new DiscordColor(x)).ToList();
 
 	/// <summary>
 	/// Gets the user's banner color integer.
 	/// </summary>
 	[JsonProperty("accent_color")]
 	internal int? BannerColorInternal;
 
 	/// <summary>
 	/// Gets the user's theme color integers.
 	/// </summary>
 	[JsonProperty("theme_colors", NullValueHandling = NullValueHandling.Ignore)]
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	internal List<int>? ThemeColorsInternal;
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 
 	/// <summary>
 	/// Gets the user's banner url
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> string.IsNullOrWhiteSpace(this.BannerHash) ? null : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}?size=4096";
 
 	/// <summary>
 	/// Gets the user's profile banner hash. Mutually exclusive with <see cref="BannerColor"/>.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the users bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Bio { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string AvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's avatar decoration hash.
 	/// </summary>
 	[JsonProperty("avatar_decoration", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string AvatarDecorationHash { get; internal set; }
 
 	/// <summary>
 	/// Returns a uri to this users profile.
 	/// </summary>
 	[JsonIgnore]
 	public Uri ProfileUri => new($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.USERS}/{this.Id}");
 
 	/// <summary>
 	/// Returns a string representing the direct URL to this users profile.
 	/// </summary>
 	/// <returns>The URL of this users profile.</returns>
 	[JsonIgnore]
 	public string ProfileUrl => this.ProfileUri.AbsoluteUri;
 
 	/// <summary>
 	/// Gets the user's avatar url.
 	/// </summary>
 	[JsonIgnore]
 	public string AvatarUrl
 		=> string.IsNullOrWhiteSpace(this.AvatarHash) ? this.DefaultAvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.AvatarHash}.{(this.AvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the user's avatar decoration url.
 	/// </summary>
 	[JsonIgnore]
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public string? AvatarDecorationUrl
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 		=> string.IsNullOrWhiteSpace(this.AvatarDecorationHash) ? null : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS_DECORATIONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.AvatarDecorationHash}.{(this.AvatarDecorationHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the URL of default avatar for this user.
 	/// </summary>
 	[JsonIgnore]
 	public string DefaultAvatarUrl
 		=> $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{(this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture)}.png?size=1024";
 
 	/// <summary>
 	/// Gets whether the user is a bot.
 	/// </summary>
 	[JsonProperty("bot", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool IsBot { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user has multi-factor authentication enabled.
 	/// </summary>
 	[JsonProperty("mfa_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool? MfaEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user is an official Discord system user.
 	/// </summary>
 	[JsonProperty("system", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsSystem { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user is verified.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonProperty("verified", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool? Verified { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's email address.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonProperty("email", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Email { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's premium type.
 	/// </summary>
 	[JsonProperty("premium_type", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual PremiumType? PremiumType { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's chosen language
 	/// </summary>
 	[JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Locale { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's flags for OAuth.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual UserFlags? OAuthFlags { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's flags.
 	/// </summary>
 	[JsonProperty("public_flags", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual UserFlags? Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's pronouns.
 	/// </summary>
 	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Pronouns { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's mention string.
 	/// </summary>
 	[JsonIgnore]
 	public string Mention
 		=> Formatter.Mention(this, this is DiscordMember);
 
 	/// <summary>
 	/// Gets whether this user is the Client which created this object.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCurrent
 		=> this.Id == this.Discord.CurrentUser.Id;
 
 	#region Extension of DiscordUser
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.CertifiedModerator"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsMod
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.CertifiedModerator);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.Partner"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsPartner
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Partner);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.VerifiedBot"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsVerifiedBot
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedBot);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.VerifiedDeveloper"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsBotDev
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedDeveloper);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.ActiveDeveloper"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsActiveDeveloper
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.ActiveDeveloper);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.Staff"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsStaff
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Staff);
 
 	#endregion
 
 	/// <summary>
 	/// Fetches the user from the API.
 	/// </summary>
 	/// <returns>The user with fresh data from the API.</returns>
 	public async Task<DiscordUser> GetFromApiAsync()
 		=> await this.Discord.ApiClient.GetUserAsync(this.Id);
 
 	/// <summary>
 	/// Gets additional information about an application if the user is an bot.
 	/// </summary>
 	/// <returns>The rpc info or <see langword="null"/></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>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 	public async Task<DiscordRpcApplication?> GetRpcInfoAsync()
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 		=> this.IsBot ? await this.Discord.ApiClient.GetApplicationInfoAsync(this.Id) : await Task.FromResult<DiscordRpcApplication?>(null);
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 
 	/// <summary>
 	/// Whether this user is in a <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <example>
 	/// <code>
 	/// DiscordGuild guild = await Client.GetGuildAsync(806675511555915806);
 	/// DiscordUser user = await Client.GetUserAsync(469957180968271873);
 	/// Console.WriteLine($"{user.Username} {(user.IsInGuild(guild) ? "is a" : "is not a")} member of {guild.Name}");
 	/// </code>
 	/// results to <c>J_M_Lutra is a member of Project Nyaw~</c>.
 	/// </example>
 	/// <param name="guild"><see cref="DiscordGuild"/></param>
 	/// <returns><see cref="bool"/></returns>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 	public async Task<bool> IsInGuild(DiscordGuild guild)
 	{
 		try
 		{
 			var member = await guild.GetMemberAsync(this.Id);
 			return member is not null;
 
 		}
 		catch (NotFoundException)
 		{
 			return false;
 		}
 	}
 
 	/// <summary>
 	/// Whether this user is not in a <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <param name="guild"><see cref="DiscordGuild"/></param>
 	/// <returns><see cref="bool"/></returns>
 	public async Task<bool> IsNotInGuild(DiscordGuild guild)
 		=> !await this.IsInGuild(guild);
 
 	/// <summary>
 	/// Returns the DiscordMember in the specified <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <param name="guild">The <see cref="DiscordGuild"/> to get this user on.</param>
 	/// <returns>The <see cref="DiscordMember"/>.</returns>
 	/// <exception cref="NotFoundException">Thrown when the user is not part of the guild.</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<DiscordMember> ConvertToMember(DiscordGuild guild)
 		=> await guild.GetMemberAsync(this.Id);
 
 	/// <summary>
 	/// Unbans this user from a guild.
 	/// </summary>
 	/// <param name="guild">Guild to unban this user from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnbanAsync(DiscordGuild guild, string reason = null)
 		=> guild.UnbanMemberAsync(this, reason);
 
 	/// <summary>
 	/// Gets this user's presence.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordPresence Presence
 		=> this.Discord is DiscordClient dc && dc.Presences.TryGetValue(this.Id, out var presence) ? presence : null;
 
 	/// <summary>
 	/// Gets the user's avatar URL, in requested format and size.
 	/// </summary>
 	/// <param name="fmt">Format of the avatar to get.</param>
 	/// <param name="size">Maximum size of the avatar. Must be a power of two, minimum 16, maximum 2048.</param>
 	/// <returns>URL of the user's avatar.</returns>
 	public string GetAvatarUrl(ImageFormat fmt, ushort size = 1024)
 	{
 		if (fmt == ImageFormat.Unknown)
 			throw new ArgumentException("You must specify valid image format.", nameof(fmt));
 
 		if (size < 16 || size > 2048)
 			throw new ArgumentOutOfRangeException(nameof(size));
 
 		var log = Math.Log(size, 2);
 		if (log < 4 || log > 11 || log % 1 != 0)
 			throw new ArgumentOutOfRangeException(nameof(size));
 
 		var sfmt = "";
 		sfmt = fmt switch
 		{
 			ImageFormat.Gif => "gif",
 			ImageFormat.Jpeg => "jpg",
 			ImageFormat.Png => "png",
 			ImageFormat.WebP => "webp",
 			ImageFormat.Auto => !string.IsNullOrWhiteSpace(this.AvatarHash) ? this.AvatarHash.StartsWith("a_") ? "gif" : "png" : "png",
 			_ => throw new ArgumentOutOfRangeException(nameof(fmt)),
 		};
 		var ssize = size.ToString(CultureInfo.InvariantCulture);
 		if (!string.IsNullOrWhiteSpace(this.AvatarHash))
 		{
 			var id = this.Id.ToString(CultureInfo.InvariantCulture);
 			return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{id}/{this.AvatarHash}.{sfmt}?size={ssize}";
 		}
 		else
 		{
 			var type = (this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture);
 			return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{type}.{sfmt}?size={ssize}";
 		}
 	}
 
+	/// <summary>
+	/// Creates a direct message channel to this user.
+	/// </summary>
+	/// <returns>Direct message channel to this user.</returns>
+	/// <exception cref="UnauthorizedException">Thrown when the user has the bot blocked, the member shares no guild with the bot, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
+	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	public Task<DiscordDmChannel> CreateDmChannelAsync()
+		=> this.Discord.ApiClient.CreateDmAsync(this.Id);
+
+	/// <summary>
+	/// Sends a direct message to this user. Creates a direct message channel if one does not exist already.
+	/// </summary>
+	/// <param name="content">Content of the message to send.</param>
+	/// <returns>The sent message.</returns>
+	/// <exception cref="UnauthorizedException">Thrown when the user has the bot blocked, the member shares no guild with the bot, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
+	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	public async Task<DiscordMessage> SendMessageAsync(string content)
+	{
+		if (this.IsBot && this.Discord.CurrentUser.IsBot)
+			throw new ArgumentException("Bots cannot DM each other.");
+
+		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
+		return await chn.SendMessageAsync(content).ConfigureAwait(false);
+	}
+
+	/// <summary>
+	/// Sends a direct message to this user. Creates a direct message channel if one does not exist already.
+	/// </summary>
+	/// <param name="embed">Embed to attach to the message.</param>
+	/// <returns>The sent message.</returns>
+	/// <exception cref="UnauthorizedException">Thrown when the user has the bot blocked, the member shares no guild with the bot, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
+	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	public async Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
+	{
+		if (this.IsBot && this.Discord.CurrentUser.IsBot)
+			throw new ArgumentException("Bots cannot DM each other.");
+
+		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
+		return await chn.SendMessageAsync(embed).ConfigureAwait(false);
+	}
+
+	/// <summary>
+	/// Sends a direct message to this user. Creates a direct message channel if one does not exist already.
+	/// </summary>
+	/// <param name="content">Content of the message to send.</param>
+	/// <param name="embed">Embed to attach to the message.</param>
+	/// <returns>The sent message.</returns>
+	/// <exception cref="UnauthorizedException">Thrown when the user has the bot blocked, the member shares no guild with the bot, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
+	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	public async Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
+	{
+		if (this.IsBot && this.Discord.CurrentUser.IsBot)
+			throw new ArgumentException("Bots cannot DM each other.");
+
+		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
+		return await chn.SendMessageAsync(content, embed).ConfigureAwait(false);
+	}
+
+	/// <summary>
+	/// Sends a direct message to this user. Creates a direct message channel if one does not exist already.
+	/// </summary>
+	/// <param name="message">Builder to with the message.</param>
+	/// <returns>The sent message.</returns>
+	/// <exception cref="UnauthorizedException">Thrown when the user has the bot blocked, the member shares no guild with the bot, or if the member has Allow DM from server members off.</exception>
+	/// <exception cref="NotFoundException">Thrown when the user does not exist.</exception>
+	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
+	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	public async Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder message)
+	{
+		if (this.IsBot && this.Discord.CurrentUser.IsBot)
+			throw new ArgumentException("Bots cannot DM each other.");
+
+		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
+		return await chn.SendMessageAsync(message).ConfigureAwait(false);
+	}
+
 	/// <summary>
 	/// Returns a string representation of this user.
 	/// </summary>
 	/// <returns>String representation of this user.</returns>
 	public override string ToString() => $"User {this.Id}; {this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordUser"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordUser"/>.</returns>
 	public override bool Equals(object obj) => this.Equals(obj as DiscordUser);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordUser"/> is equal to another <see cref="DiscordUser"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordUser"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordUser"/> is equal to this <see cref="DiscordUser"/>.</returns>
 	public bool Equals(DiscordUser e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordUser"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordUser"/>.</returns>
 	public override int GetHashCode() => this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordUser"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First user to compare.</param>
 	/// <param name="e2">Second user to compare.</param>
 	/// <returns>Whether the two users are equal.</returns>
 	public static bool operator ==(DiscordUser e1, DiscordUser e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordUser"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First user to compare.</param>
 	/// <param name="e2">Second user to compare.</param>
 	/// <returns>Whether the two users are not equal.</returns>
 	public static bool operator !=(DiscordUser e1, DiscordUser e2)
 		=> !(e1 == e2);
 }
 
 /// <summary>
 /// Represents a user comparer.
 /// </summary>
 internal class DiscordUserComparer : IEqualityComparer<DiscordUser>
 {
 	/// <summary>
 	/// Whether the users are equal.
 	/// </summary>
 	/// <param name="x">The first user</param>
 	/// <param name="y">The second user.</param>
 	public bool Equals(DiscordUser x, DiscordUser y) => x.Equals(y);
 
 	/// <summary>
 	/// Gets the hash code.
 	/// </summary>
 	/// <param name="obj">The user.</param>
 	public int GetHashCode(DiscordUser obj) => obj.Id.GetHashCode();
 }