diff --git a/DisCatSharp.CommandsNext/Attributes/CooldownAttribute.cs b/DisCatSharp.CommandsNext/Attributes/CooldownAttribute.cs
index a3d6965b6..a088a865f 100644
--- a/DisCatSharp.CommandsNext/Attributes/CooldownAttribute.cs
+++ b/DisCatSharp.CommandsNext/Attributes/CooldownAttribute.cs
@@ -1,342 +1,333 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Globalization;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.CommandsNext.Attributes
 {
     /// <summary>
     /// Defines a cooldown for this command. This allows you to define how many times can users execute a specific command
     /// </summary>
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
     public sealed class CooldownAttribute : CheckBaseAttribute
     {
         /// <summary>
         /// Gets the maximum number of uses before this command triggers a cooldown for its bucket.
         /// </summary>
         public int MaxUses { get; }
 
         /// <summary>
         /// Gets the time after which the cooldown is reset.
         /// </summary>
         public TimeSpan Reset { get; }
 
         /// <summary>
         /// Gets the type of the cooldown bucket. This determines how cooldowns are applied.
         /// </summary>
         public CooldownBucketType BucketType { get; }
 
         /// <summary>
         /// Gets the cooldown buckets for this command.
         /// </summary>
         private ConcurrentDictionary<string, CommandCooldownBucket> Buckets { get; }
 
         /// <summary>
         /// Defines a cooldown for this command. This means that users will be able to use the command a specific number of times before they have to wait to use it again.
         /// </summary>
         /// <param name="maxUses">Number of times the command can be used before triggering a cooldown.</param>
         /// <param name="resetAfter">Number of seconds after which the cooldown is reset.</param>
         /// <param name="bucketType">Type of cooldown bucket. This allows controlling whether the bucket will be cooled down per user, guild, channel, or globally.</param>
         public CooldownAttribute(int maxUses, double resetAfter, CooldownBucketType bucketType)
         {
             this.MaxUses = maxUses;
             this.Reset = TimeSpan.FromSeconds(resetAfter);
             this.BucketType = bucketType;
             this.Buckets = new ConcurrentDictionary<string, CommandCooldownBucket>();
         }
 
         /// <summary>
         /// Gets a cooldown bucket for given command context.
         /// </summary>
         /// <param name="ctx">Command context to get cooldown bucket for.</param>
         /// <returns>Requested cooldown bucket, or null if one wasn't present.</returns>
         public CommandCooldownBucket GetBucket(CommandContext ctx)
         {
             var bid = this.GetBucketId(ctx, out _, out _, out _);
             this.Buckets.TryGetValue(bid, out var bucket);
             return bucket;
         }
 
         /// <summary>
         /// Calculates the cooldown remaining for given command context.
         /// </summary>
         /// <param name="ctx">Context for which to calculate the cooldown.</param>
         /// <returns>Remaining cooldown, or zero if no cooldown is active.</returns>
         public TimeSpan GetRemainingCooldown(CommandContext ctx)
         {
             var bucket = this.GetBucket(ctx);
             return bucket == null ? TimeSpan.Zero : bucket.RemainingUses > 0 ? TimeSpan.Zero : bucket.ResetsAt - DateTimeOffset.UtcNow;
         }
 
         /// <summary>
         /// Calculates bucket ID for given command context.
         /// </summary>
         /// <param name="ctx">Context for which to calculate bucket ID for.</param>
         /// <param name="userId">ID of the user with which this bucket is associated.</param>
         /// <param name="channelId">ID of the channel with which this bucket is associated.</param>
         /// <param name="guildId">ID of the guild with which this bucket is associated.</param>
         /// <returns>Calculated bucket ID.</returns>
         private string GetBucketId(CommandContext ctx, out ulong userId, out ulong channelId, out ulong guildId)
         {
             userId = 0ul;
             if ((this.BucketType & CooldownBucketType.User) != 0)
                 userId = ctx.User.Id;
 
             channelId = 0ul;
             if ((this.BucketType & CooldownBucketType.Channel) != 0)
                 channelId = ctx.Channel.Id;
             if ((this.BucketType & CooldownBucketType.Guild) != 0 && ctx.Guild == null)
                 channelId = ctx.Channel.Id;
 
             guildId = 0ul;
             if (ctx.Guild != null && (this.BucketType & CooldownBucketType.Guild) != 0)
                 guildId = ctx.Guild.Id;
 
             var bid = CommandCooldownBucket.MakeId(userId, channelId, guildId);
             return bid;
         }
 
         /// <summary>
         /// Executes 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 (help)
                 return true;
 
             var bid = this.GetBucketId(ctx, out var usr, out var chn, out var gld);
             if (!this.Buckets.TryGetValue(bid, out var bucket))
             {
                 bucket = new CommandCooldownBucket(this.MaxUses, this.Reset, usr, chn, gld);
                 this.Buckets.AddOrUpdate(bid, bucket, (k, v) => bucket);
             }
 
             return await bucket.DecrementUseAsync().ConfigureAwait(false);
         }
     }
 
     /// <summary>
     /// Defines how are command cooldowns applied.
     /// </summary>
     public enum CooldownBucketType : int
     {
         /// <summary>
         /// Denotes that the command will have its cooldown applied per-user.
         /// </summary>
         User = 1,
 
         /// <summary>
         /// Denotes that the command will have its cooldown applied per-channel.
         /// </summary>
         Channel = 2,
 
         /// <summary>
         /// Denotes that the command will have its cooldown applied per-guild. In DMs, this applies the cooldown per-channel.
         /// </summary>
         Guild = 4,
 
         /// <summary>
         /// Denotes that the command will have its cooldown applied globally.
         /// </summary>
         Global = 0
     }
 
     /// <summary>
     /// Represents a cooldown bucket for commands.
     /// </summary>
     public sealed class CommandCooldownBucket : IEquatable<CommandCooldownBucket>
     {
         /// <summary>
         /// Gets the ID of the user with whom this cooldown is associated.
         /// </summary>
         public ulong UserId { get; }
 
         /// <summary>
         /// Gets the ID of the channel with which this cooldown is associated.
         /// </summary>
         public ulong ChannelId { get; }
 
         /// <summary>
         /// Gets the ID of the guild with which this cooldown is associated.
         /// </summary>
         public ulong GuildId { get; }
 
         /// <summary>
         /// Gets the ID of the bucket. This is used to distinguish between cooldown buckets.
         /// </summary>
         public string BucketId { get; }
 
         /// <summary>
         /// Gets the remaining number of uses before the cooldown is triggered.
         /// </summary>
         public int RemainingUses
             => Volatile.Read(ref this._remaining_uses);
 
         private int _remaining_uses;
 
         /// <summary>
         /// Gets the maximum number of times this command can be used in given timespan.
         /// </summary>
         public int MaxUses { get; }
 
         /// <summary>
         /// Gets the date and time at which the cooldown resets.
         /// </summary>
         public DateTimeOffset ResetsAt { get; internal set; }
 
         /// <summary>
         /// Gets the time after which this cooldown resets.
         /// </summary>
         public TimeSpan Reset { get; internal set; }
 
         /// <summary>
         /// Gets the semaphore used to lock the use value.
         /// </summary>
         private SemaphoreSlim UsageSemaphore { get; }
 
         /// <summary>
         /// Creates a new command cooldown bucket.
         /// </summary>
         /// <param name="maxUses">Maximum number of uses for this bucket.</param>
         /// <param name="resetAfter">Time after which this bucket resets.</param>
         /// <param name="userId">ID of the user with which this cooldown is associated.</param>
         /// <param name="channelId">ID of the channel with which this cooldown is associated.</param>
         /// <param name="guildId">ID of the guild with which this cooldown is associated.</param>
         internal CommandCooldownBucket(int maxUses, TimeSpan resetAfter, ulong userId = 0, ulong channelId = 0, ulong guildId = 0)
         {
             this._remaining_uses = maxUses;
             this.MaxUses = maxUses;
             this.ResetsAt = DateTimeOffset.UtcNow + resetAfter;
             this.Reset = resetAfter;
             this.UserId = userId;
             this.ChannelId = channelId;
             this.GuildId = guildId;
             this.BucketId = MakeId(userId, channelId, guildId);
             this.UsageSemaphore = new SemaphoreSlim(1, 1);
         }
 
         /// <summary>
         /// Decrements the remaining use counter.
         /// </summary>
         /// <returns>Whether decrement succeded or not.</returns>
         internal async Task<bool> DecrementUseAsync()
         {
             await this.UsageSemaphore.WaitAsync().ConfigureAwait(false);
 
             // if we're past reset time...
             var now = DateTimeOffset.UtcNow;
             if (now >= this.ResetsAt)
             {
                 // ...do the reset and set a new reset time
                 Interlocked.Exchange(ref this._remaining_uses, this.MaxUses);
                 this.ResetsAt = now + this.Reset;
             }
 
             // check if we have any uses left, if we do...
             var success = false;
             if (this.RemainingUses > 0)
             {
                 // ...decrement, and return success...
                 Interlocked.Decrement(ref this._remaining_uses);
                 success = true;
             }
 
             // ...otherwise just fail
             this.UsageSemaphore.Release();
             return success;
         }
 
         /// <summary>
         /// Returns a string representation of this command cooldown bucket.
         /// </summary>
         /// <returns>String representation of this command cooldown bucket.</returns>
         public override string ToString() => $"Command bucket {this.BucketId}";
 
         /// <summary>
         /// Checks whether this <see cref="CommandCooldownBucket"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="CommandCooldownBucket"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as CommandCooldownBucket);
 
         /// <summary>
         /// Checks whether this <see cref="CommandCooldownBucket"/> is equal to another <see cref="CommandCooldownBucket"/>.
         /// </summary>
         /// <param name="other"><see cref="CommandCooldownBucket"/> to compare to.</param>
         /// <returns>Whether the <see cref="CommandCooldownBucket"/> is equal to this <see cref="CommandCooldownBucket"/>.</returns>
         public bool Equals(CommandCooldownBucket other) => other is not null && (ReferenceEquals(this, other) || (this.UserId == other.UserId && this.ChannelId == other.ChannelId && this.GuildId == other.GuildId));
 
         /// <summary>
         /// Gets the hash code for this <see cref="CommandCooldownBucket"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="CommandCooldownBucket"/>.</returns>
-        public override int GetHashCode()
-        {
-            var hash = 13;
-
-            hash = (hash * 7) + this.UserId.GetHashCode();
-            hash = (hash * 7) + this.ChannelId.GetHashCode();
-            hash = (hash * 7) + this.GuildId.GetHashCode();
-
-            return hash;
-        }
+        public override int GetHashCode() => HashCode.Combine(this.UserId, this.ChannelId, this.GuildId);
 
         /// <summary>
         /// Gets whether the two <see cref="CommandCooldownBucket"/> objects are equal.
         /// </summary>
         /// <param name="bucket1">First bucket to compare.</param>
         /// <param name="bucket2">Second bucket to compare.</param>
         /// <returns>Whether the two buckets are equal.</returns>
         public static bool operator ==(CommandCooldownBucket bucket1, CommandCooldownBucket bucket2)
         {
             var null1 = bucket1 is null;
             var null2 = bucket2 is null;
 
             return (null1 && null2) || (null1 == null2 && null1.Equals(null2));
         }
 
         /// <summary>
         /// Gets whether the two <see cref="CommandCooldownBucket"/> objects are not equal.
         /// </summary>
         /// <param name="bucket1">First bucket to compare.</param>
         /// <param name="bucket2">Second bucket to compare.</param>
         /// <returns>Whether the two buckets are not equal.</returns>
         public static bool operator !=(CommandCooldownBucket bucket1, CommandCooldownBucket bucket2)
             => !(bucket1 == bucket2);
 
         /// <summary>
         /// Creates a bucket ID from given bucket parameters.
         /// </summary>
         /// <param name="userId">ID of the user with which this cooldown is associated.</param>
         /// <param name="channelId">ID of the channel with which this cooldown is associated.</param>
         /// <param name="guildId">ID of the guild with which this cooldown is associated.</param>
         /// <returns>Generated bucket ID.</returns>
         public static string MakeId(ulong userId = 0, ulong channelId = 0, ulong guildId = 0)
             => $"{userId.ToString(CultureInfo.InvariantCulture)}:{channelId.ToString(CultureInfo.InvariantCulture)}:{guildId.ToString(CultureInfo.InvariantCulture)}";
     }
 }
diff --git a/DisCatSharp.Hosting.Tests/GlobalSuppressions.cs b/DisCatSharp.Hosting.Tests/GlobalSuppressions.cs
index b0f832543..25642d608 100644
--- a/DisCatSharp.Hosting.Tests/GlobalSuppressions.cs
+++ b/DisCatSharp.Hosting.Tests/GlobalSuppressions.cs
@@ -1,20 +1,26 @@
 // This file is used by Code Analysis to maintain SuppressMessage
 // attributes that are applied to this project.
 // Project-level suppressions either have no target or are given
 // a specific target and scoped to a namespace, type, member, etc.
 
 using System.Diagnostics.CodeAnalysis;
 
 [assembly: SuppressMessage("DocumentationHeader", "ClassDocumentationHeader:The class must have a documentation header.", Justification = "<Pending>")]
 [assembly: SuppressMessage("DocumentationHeader", "MethodDocumentationHeader:The method must have a documentation header.", Justification = "<Pending>")]
 [assembly: SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Hosting.Tests.HostExtensionTests._discordConfig")]
 [assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Hosting.Tests.HostExtensionTests._discordConfig")]
 [assembly: SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Hosting.Tests.HostExtensionTests._interactivityConfig")]
 [assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Hosting.Tests.HostExtensionTests._interactivityConfig")]
 [assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Hosting.Tests.HostExtensionTests._lavalinkConfig")]
 [assembly: SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Hosting.Tests.HostExtensionTests._lavalinkConfig")]
 [assembly: SuppressMessage("DocumentationHeader", "ConstructorDocumentationHeader:The constructor must have a documentation header.", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.Bot.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{DisCatSharp.Hosting.DiscordHostedService},System.IServiceProvider)")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.HostExtensionTests.DefaultDiscord~System.Collections.Generic.Dictionary{System.String,System.String}")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.HostExtensionTests.DiscordInteractivityAndLavaLinkConfiguration~Microsoft.Extensions.Configuration.IConfiguration")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.HostTests.Create(System.Collections.Generic.Dictionary{System.String,System.String})~Microsoft.Extensions.Hosting.IHostBuilder")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.HostTests.DefaultDiscord~System.Collections.Generic.Dictionary{System.String,System.String}")]
+[assembly: SuppressMessage("DocumentationHeader", "ConstructorDocumentationHeader:The constructor must have a documentation header.", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.Bot.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{DisCatSharp.Hosting.Tests.Bot},System.IServiceProvider)")]
+[assembly: SuppressMessage("DocumentationHeader", "ConstructorDocumentationHeader:The constructor must have a documentation header.", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.BotTwoService.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{DisCatSharp.Hosting.Tests.BotTwoService},System.IServiceProvider)")]
+[assembly: SuppressMessage("DocumentationHeader", "ConstructorDocumentationHeader:The constructor must have a documentation header.", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.MyCustomBot.#ctor(Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger{DisCatSharp.Hosting.Tests.MyCustomBot},System.IServiceProvider)")]
+[assembly: SuppressMessage("DocumentationHeader", "InterfaceDocumentationHeader:The interface must have a documentation header.", Justification = "<Pending>", Scope = "type", Target = "~T:DisCatSharp.Hosting.Tests.IBotTwoService")]
+[assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.HostTests.Create(System.String)~Microsoft.Extensions.Hosting.IHostBuilder")]
+[assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.Hosting.Tests.HostTests.Create``2(System.String)~Microsoft.Extensions.Hosting.IHostBuilder")]
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index ceb6bb3e7..94c29b996 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1339 +1,1356 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a discord channel.
     /// </summary>
     public class DiscordChannel : SnowflakeObject, IEquatable<DiscordChannel>
     {
         /// <summary>
         /// Gets ID of the guild to which this channel belongs.
         /// </summary>
         [JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? GuildId { get; internal set; }
 
         /// <summary>
         /// Gets ID of the category that contains this channel.
         /// </summary>
         [JsonProperty("parent_id", NullValueHandling = NullValueHandling.Include)]
         public ulong? ParentId { get; internal set; }
 
         /// <summary>
         /// Gets the category that contains this channel.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel Parent
             => this.ParentId.HasValue ? this.Guild.GetChannel(this.ParentId.Value) : null;
 
         /// <summary>
         /// Gets the name of this channel.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; internal set; }
 
         /// <summary>
         /// Gets the type of this channel.
         /// </summary>
         [JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
         public ChannelType Type { get; internal set; }
 
         /// <summary>
         /// Gets the position of this channel.
         /// </summary>
         [JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
         public int Position { get; internal set; }
 
         /// <summary>
         /// Gets the maximum available position to move the channel to.
         /// This can contain outdated informations.
         /// </summary>
         public int GetMaxPosition()
         {
             var channels = this.Guild.Channels.Values;
             return this.ParentId != null
                 ? this.Type == ChannelType.Text || this.Type == ChannelType.News
                     ? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).ToArray().Last().Position
                     : this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
                         ? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).ToArray().Last().Position
                         : channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().Last().Position
                 : channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().Last().Position;
         }
 
         /// <summary>
         /// Gets the minimum available position to move the channel to.
         /// </summary>
         public int GetMinPosition()
         {
             var channels = this.Guild.Channels.Values;
             return this.ParentId != null
                 ? this.Type == ChannelType.Text || this.Type == ChannelType.News
                     ? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).ToArray().First().Position
                     : this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
                         ? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).ToArray().First().Position
                         : channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().First().Position
                 : channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().First().Position;
         }
 
         /// <summary>
         /// Gets whether this channel is a DM channel.
         /// </summary>
         [JsonIgnore]
         public bool IsPrivate
             => this.Type == ChannelType.Private || this.Type == ChannelType.Group;
 
         /// <summary>
         /// Gets whether this channel is a channel category.
         /// </summary>
         [JsonIgnore]
         public bool IsCategory
             => this.Type == ChannelType.Category;
 
         /// <summary>
         /// Gets whether this channel is a stage channel.
         /// </summary>
         [JsonIgnore]
         public bool IsStage
             => this.Type == ChannelType.Stage;
 
         /// <summary>
         /// Gets the guild to which this channel belongs.
         /// </summary>
         [JsonIgnore]
         public DiscordGuild Guild
             => this.GuildId.HasValue && this.Discord.Guilds.TryGetValue(this.GuildId.Value, out var guild) ? guild : null;
 
         /// <summary>
         /// Gets a collection of permission overwrites for this channel.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordOverwrite> PermissionOverwrites
             => this._permissionOverwritesLazy.Value;
 
         [JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
         internal List<DiscordOverwrite> _permissionOverwrites = new();
         [JsonIgnore]
         private readonly Lazy<IReadOnlyList<DiscordOverwrite>> _permissionOverwritesLazy;
 
         /// <summary>
         /// Gets the channel's topic. This is applicable to text channels only.
         /// </summary>
         [JsonProperty("topic", NullValueHandling = NullValueHandling.Ignore)]
         public string Topic { get; internal set; }
 
         /// <summary>
         /// Gets the ID of the last message sent in this channel. This is applicable to text channels only.
         /// </summary>
         [JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? LastMessageId { get; internal set; }
 
         /// <summary>
         /// Gets this channel's bitrate. This is applicable to voice channels only.
         /// </summary>
         [JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
         public int? Bitrate { get; internal set; }
 
         /// <summary>
         /// Gets this channel's user limit. This is applicable to voice channels only.
         /// </summary>
         [JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
         public int? UserLimit { get; internal set; }
 
         /// <summary>
         /// <para>Gets the slow mode delay configured for this channel.</para>
         /// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slow mode.</para>
         /// </summary>
         [JsonProperty("rate_limit_per_user")]
         public int? PerUserRateLimit { get; internal set; }
 
         /// <summary>
         /// Gets this channel's video quality mode. This is applicable to voice channels only.
         /// </summary>
         [JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
         public VideoQualityMode? QualityMode { get; internal set; }
 
         /// <summary>
         /// Gets when the last pinned message was pinned.
         /// </summary>
         [JsonIgnore]
         public DateTimeOffset? LastPinTimestamp
             => !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
                 dto : null;
 
         /// <summary>
         /// Gets when the last pinned message was pinned as raw string.
         /// </summary>
         [JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
         internal string LastPinTimestampRaw { get; set; }
 
         /// <summary>
         /// Gets this channel's default duration for newly created threads, in minutes, to automatically archive the thread after recent activity.
         /// </summary>
         [JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
         public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; internal set; }
 
         /// <summary>
         /// Gets this channel's mention string.
         /// </summary>
         [JsonIgnore]
         public string Mention
             => Formatter.Mention(this);
 
         /// <summary>
         /// Gets this channel's children. This applies only to channel categories.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyList<DiscordChannel> Children
         {
             get
             {
                 return !this.IsCategory
                     ? throw new ArgumentException("Only channel categories contain children.")
                     : this.Guild._channels.Values.Where(e => e.ParentId == this.Id).ToList();
             }
         }
 
         /// <summary>
         /// Gets the list of members currently in the channel (if voice channel), or members who can see the channel (otherwise).
         /// </summary>
         [JsonIgnore]
         public virtual IReadOnlyList<DiscordMember> Users
         {
             get
             {
                 return this.Guild == null
                     ? throw new InvalidOperationException("Cannot query users outside of guild channels.")
-                    : this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
+                    : this.IsVoiceJoinable()
                     ? this.Guild.Members.Values.Where(x => x.VoiceState?.ChannelId == this.Id).ToList()
                     : this.Guild.Members.Values.Where(x => (this.PermissionsFor(x) & Permissions.AccessChannels) == Permissions.AccessChannels).ToList();
             }
         }
 
         /// <summary>
         /// Gets whether this channel is an NSFW channel.
         /// </summary>
         [JsonProperty("nsfw")]
         public bool IsNSFW { get; internal set; }
 
         /// <summary>
         /// Gets this channel's region id (if voice channel).
         /// </summary>
         [JsonProperty("rtc_region", NullValueHandling = NullValueHandling.Ignore)]
         internal string RtcRegionId { get; set; }
 
         /// <summary>
         /// Gets this channel's region override (if voice channel).
         /// </summary>
         [JsonIgnore]
         public DiscordVoiceRegion RtcRegion
             => this.RtcRegionId != null ? this.Discord.VoiceRegions[this.RtcRegionId] : null;
 
 
         /// <summary>
         /// Only sent on the resolved channels of interaction responses for application commands. Gets the permissions of the user in this channel who invoked the command.
         /// </summary>
         [JsonProperty("permissions")]
         public Permissions? UserPermissions { get; internal set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordChannel"/> class.
         /// </summary>
         internal DiscordChannel()
         {
             this._permissionOverwritesLazy = new Lazy<IReadOnlyList<DiscordOverwrite>>(() => new ReadOnlyCollection<DiscordOverwrite>(this._permissionOverwrites));
         }
 
         #region Methods
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
         /// <exception cref="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(string content)
         {
-            return this.Type != ChannelType.Text && this.Type != ChannelType.Private && this.Type != ChannelType.Group && this.Type != ChannelType.News
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
         /// <exception cref="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(DiscordEmbed embed)
         {
-            return this.Type != ChannelType.Text && this.Type != ChannelType.Private && this.Type != ChannelType.Group && this.Type != ChannelType.News
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
         /// <exception cref="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(string content, DiscordEmbed embed)
         {
-            return this.Type != ChannelType.Text && this.Type != ChannelType.Private && this.Type != ChannelType.Group && this.Type != ChannelType.News
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="builder">The builder with all the items to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
         /// <exception cref="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(DiscordMessageBuilder builder)
             => this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="action">The builder with all the items to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
         /// <exception cref="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(Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
 
 
-            return this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
+            return !this.IsWriteable()
+                ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
+                : this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
         }
 
         /// <summary>
         /// Deletes a guild channel
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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 DeleteAsync(string reason = null)
             => this.Discord.ApiClient.DeleteChannelAsync(this.Id, reason);
 
         /// <summary>
         /// Clones this channel. This operation will create a channel with identical settings to this one. Note that this will not copy messages.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <returns>Newly-created channel.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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 async Task<DiscordChannel> CloneAsync(string reason = null)
         {
             if (this.Guild == null)
                 throw new InvalidOperationException("Non-guild channels cannot be cloned.");
 
             var ovrs = new List<DiscordOverwriteBuilder>();
             foreach (var ovr in this._permissionOverwrites)
 #pragma warning disable CS0618 // Type or member is obsolete
                 ovrs.Add(await new DiscordOverwriteBuilder().FromAsync(ovr).ConfigureAwait(false));
 #pragma warning restore CS0618 // Type or member is obsolete
 
             var bitrate = this.Bitrate;
             var userLimit = this.UserLimit;
             Optional<int?> perUserRateLimit = this.PerUserRateLimit;
 
-            if (this.Type != ChannelType.Voice)
+            if(!this.IsVoiceJoinable())
             {
                 bitrate = null;
                 userLimit = null;
             }
-            if (this.Type != ChannelType.Text)
+
+            if (this.Type == ChannelType.Stage)
+            {
+                userLimit = null;
+            }
+            if (!this.IsWriteable())
             {
                 perUserRateLimit = Optional.FromNoValue<int?>();
             }
 
             return await this.Guild.CreateChannelAsync(this.Name, this.Type, this.Parent, this.Topic, bitrate, userLimit, ovrs, this.IsNSFW, perUserRateLimit, this.QualityMode, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a specific message
         /// </summary>
         /// <param name="id">The id of the message</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> 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 async Task<DiscordMessage> GetMessageAsync(ulong id)
         {
             return this.Discord.Configuration.MessageCacheSize > 0
                 && this.Discord is DiscordClient dc
                 && dc.MessageCache != null
                 && dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
                 ? msg
                 : await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Modifies the current channel.
         /// </summary>
         /// <param name="action">Action to perform on this channel</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
         /// <exception cref="NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</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 ModifyAsync(Action<ChannelEditModel> action)
         {
             var mdl = new ChannelEditModel();
             action(mdl);
 
             if (mdl.DefaultAutoArchiveDuration.HasValue)
             {
                 if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value))
                     throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
             }
 
             return this.Discord.ApiClient.ModifyChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Nsfw,
                 mdl.Parent.HasValue ? mdl.Parent.Value?.Id : default(Optional<ulong?>), mdl.Bitrate, mdl.Userlimit, mdl.PerUserRateLimit, mdl.RtcRegion.IfPresent(r => r?.Id),
                 mdl.QualityMode, mdl.DefaultAutoArchiveDuration, mdl.Type, mdl.PermissionOverwrites, mdl.AuditLogReason);
         }
 
         /// <summary>
         /// Updates the channel position when it doesn't have a category.
         /// 
         /// Use <see cref="ModifyParentAsync"/> for moving to other categories.
         /// Use <see cref="RemoveParentAsync"/> to move out of a category.
         /// Use <see cref="ModifyPositionInCategoryAsync"/> for moving within a category.
         /// </summary>
         /// <param name="position">Position the channel should be moved to.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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>
         [Obsolete("This will be replaced by ModifyPositionInCategoryAsync. Use it instead.")]
         public Task ModifyPositionAsync(int position, string reason = null)
         {
             if (this.Guild == null)
                 throw new ArgumentException("Cannot modify order of non-guild channels.");
+            if (!this.IsMovable())
+                throw new NotSupportedException("You can't move this type of channel in categories.");
             if (this.ParentId != null)
                 throw new ArgumentException("Cannot modify order of channels within a category. Use ModifyPositionInCategoryAsync instead.");
 
             var chns = this.Guild._channels.Values.Where(xc => xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray();
             var pmds = new RestGuildChannelReorderPayload[chns.Length];
             for (var i = 0; i < chns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelReorderPayload
                 {
                     ChannelId = chns[i].Id,
                 };
 
                 pmds[i].Position = chns[i].Id == this.Id ? position : chns[i].Position >= position ? chns[i].Position + 1 : chns[i].Position;
             }
 
             return this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason);
         }
 
         /// <summary>
         /// Updates the channel position within it's own category.
         ///
         /// Use <see cref="ModifyParentAsync"/> for moving to other categories.
         /// Use <see cref="RemoveParentAsync"/> to move out of a category.
         /// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
         /// </summary>
         /// <param name="position">The position.</param>
         /// <param name="reason">The reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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="IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
         /// <exception cref="ArgumentException">Thrown when function is called on a channel without a parent channel.</exception>
         public async Task ModifyPositionInCategoryAsync(int position, string reason = null)
         {
             //if (this.ParentId == null)
             //    throw new ArgumentException("You can call this function only on channels in categories.");
 
+            if (!this.IsMovableInParent())
+                throw new NotSupportedException("You can't move this type of channel in categories.");
+
             var isUp = position > this.Position;
 
             var channels = await this.InternalRefreshChannelsAsync();
 
             var chns = this.ParentId != null
                 ? this.Type == ChannelType.Text || this.Type == ChannelType.News
                     ? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
                     : this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
                         ? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
                         : channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type)
                 : this.Type == ChannelType.Text || this.Type == ChannelType.News
                     ? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
                     : this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
                         ? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
                         : channels.Where(xc => xc.ParentId == null && xc.Type == this.Type);
 
             var ochns = chns.OrderBy(xc => xc.Position).ToArray();
             var min = ochns.First().Position;
             var max = ochns.Last().Position;
 
             if (position > max || position < min)
                 throw new IndexOutOfRangeException($"Position is not in range. {position} is {(position > max ? "greater then the maximal" : "lower then the minimal")} position.");
 
             var pmds = new RestGuildChannelReorderPayload[ochns.Length];
             for (var i = 0; i < ochns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelReorderPayload
                 {
                     ChannelId = ochns[i].Id,
                 };
 
                 if (ochns[i].Id == this.Id)
                 {
                     pmds[i].Position = position;
                 }
                 else
                 {
                     if (isUp)
                     {
                         if (ochns[i].Position <= position && ochns[i].Position > this.Position)
                         {
                             pmds[i].Position = ochns[i].Position - 1;
                         }
                         else if (ochns[i].Position < this.Position || ochns[i].Position > position)
                         {
                             pmds[i].Position = ochns[i].Position;
                         }
                     }
                     else
                     {
                         if (ochns[i].Position >= position && ochns[i].Position < this.Position)
                         {
                             pmds[i].Position = ochns[i].Position + 1;
                         }
                         else if (ochns[i].Position > this.Position || ochns[i].Position < position)
                         {
                             pmds[i].Position = ochns[i].Position;
                         }
                     }
                 }
             }
 
             await this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Internaly refreshes the channel list.
         /// </summary>
         private async Task<IReadOnlyList<DiscordChannel>> InternalRefreshChannelsAsync()
         {
             await this.RefreshPositionsAsync();
             return this.Guild.Channels.Values.ToList().AsReadOnly();
         }
 
         /// <summary>
         /// Refreshes the positions.
         /// </summary>
         public async Task RefreshPositionsAsync()
         {
             var channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Guild.Id);
             this.Guild._channels.Clear();
             foreach (var channel in channels.ToList())
             {
                 channel.Discord = this.Discord;
                 foreach (var xo in channel._permissionOverwrites)
                 {
                     xo.Discord = this.Discord;
                     xo._channel_id = channel.Id;
                 }
                 this.Guild._channels[channel.Id] = channel;
             }
         }
 
         /// <summary>
         /// Updates the channel position within it's own category.
         /// Valid modes: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up.
         /// 
         /// Use <see cref="ModifyParentAsync"/> for moving to other categories.
         /// Use <see cref="RemoveParentAsync"/> to move out of a category.
         /// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
         /// </summary>
         /// <param name="mode">The mode. Valid: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up</param>
         /// <param name="position">The position.</param>
         /// <param name="reason">The reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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="IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
         /// <exception cref="ArgumentException">Thrown when function is called on a channel without a parent channel, a wrong mode is givven or given position is zero.</exception>
         public Task ModifyPositionInCategorySmartAsync(string mode, int position, string reason = null)
         {
+            if (!this.IsMovableInParent())
+                throw new NotSupportedException("You can't move this type of channel in categories.");
+
             if (mode != "+" && mode != "-" && mode != "down" && mode != "up")
                 throw new ArgumentException("Error with the selected mode: Valid is '+' or 'down' to move a channel down and '-' or 'up' to move a channel up");
 
             var positive = mode == "+" || mode == "positive" || mode == "down";
             var negative = mode == "-" || mode == "negative" || mode == "up";
             return positive
                 ? position < this.GetMaxPosition()
                     ? this.ModifyPositionInCategoryAsync(this.Position + position, reason)
                     : throw new IndexOutOfRangeException($"Position is not in range of category.")
                 : negative
                     ? position > this.GetMinPosition()
                         ? this.ModifyPositionInCategoryAsync(this.Position - position, reason)
                         : throw new IndexOutOfRangeException($"Position is not in range of category.")
                     : throw new ArgumentException("You can only modify with +X or -X. 0 is not valid.");
         }
 
         /// <summary>
         /// Updates the channel parent, moving the channel to the bottom of the new category.
         /// </summary>
         /// <param name="newParent">New parent for channel. Will move out of parent if null.</param>
         /// <param name="lock_permissions">Sync permissions with parent. Defaults to null.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
         public Task ModifyParentAsync(DiscordChannel? newParent = null, bool? lock_permissions = null, string reason = null)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
         {
             if (this.Guild == null)
                 throw new ArgumentException("Cannot modify parent of non-guild channels.");
-            if (this.IsCategory)
-                throw new ArgumentException("Cannot modify parent of category channels.");
+            if (!this.IsMovableInParent())
+                throw new NotSupportedException("You can't move this type of channel in categories.");
             if (newParent.Type is not ChannelType.Category)
                 throw new ArgumentException("Only category type channels can be parents.");
 
 
             var position = this.Guild._channels.Values.Where(xc => xc.Type == this.Type && xc.ParentId == newParent.Id) // gets list same type channels in parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
             var chns = this.Guild._channels.Values.Where(xc => xc.Type == this.Type)
                             .OrderBy(xc => xc.Position).ToArray();
 
             var pmds = new RestGuildChannelNewParentPayload[chns.Length];
 
             for (var i = 0; i < chns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelNewParentPayload
                 {
                     ChannelId = chns[i].Id,
                     Position = chns[i].Position >= position ? chns[i].Position + 1 : chns[i].Position,
                 };
                 if (chns[i].Id == this.Id)
                 {
                     pmds[i].Position = position;
                     pmds[i].ParentId = newParent is not null ? newParent.Id : null;
                     pmds[i].LockPermissions = lock_permissions;
                 }
             }
 
             return this.Discord.ApiClient.ModifyGuildChannelParentAsync(this.Guild.Id, pmds, reason);
         }
 
         /// <summary>
         /// Moves the channel out of a category.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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 RemoveParentAsync(string reason = null)
         {
             if (this.Guild == null)
                 throw new ArgumentException("Cannot modify parent of non-guild channels.");
-            if (this.IsCategory)
-                throw new ArgumentException("Cannot modify parent of category channels.");
+            if (!this.IsMovableInParent())
+                throw new NotSupportedException("You can't move this type of channel in categories.");
 
             var position = this.Guild._channels.Values.Where(xc => xc.Type == this.Type && xc.Parent is null) //gets list of same type channels with no parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
             var chns = this.Guild._channels.Values.Where(xc => xc.Type == this.Type)
                 .OrderBy(xc => xc.Position).ToArray();
 
             var pmds = new RestGuildChannelNoParentPayload[chns.Length];
 
             for (var i = 0; i < chns.Length; i++)
             {
                 pmds[i] = new RestGuildChannelNoParentPayload
                 {
                     ChannelId = chns[i].Id,
                 };
                 if (chns[i].Id == this.Id)
                 {
                     pmds[i].Position = 1;
                     pmds[i].ParentId = null;
                 }
                 else
                 {
                     pmds[i].Position = chns[i].Position < this.Position ? chns[i].Position + 1 : chns[i].Position;
                 }
             }
 
             return this.Discord.ApiClient.DetachGuildChannelParentAsync(this.Guild.Id, pmds, reason);
         }
 
         /// <summary>
         /// Returns a list of messages before a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="before">Message to fetch before from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> 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<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
             => this.GetMessagesInternalAsync(limit, before, null, null);
 
         /// <summary>
         /// Returns a list of messages after a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="after">Message to fetch after from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> 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<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, after, null);
 
         /// <summary>
         /// Returns a list of messages around a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="around">Message to fetch around from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> 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<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, null, around);
 
         /// <summary>
         /// Returns a list of messages from the last message in the channel.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> 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<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
             this.GetMessagesInternalAsync(limit, null, null, null);
 
         /// <summary>
         /// Returns a list of messages
         /// </summary>
         /// <param name="limit">How many messages should be returned.</param>
         /// <param name="before">Get messages before snowflake.</param>
         /// <param name="after">Get messages after snowflake.</param>
         /// <param name="around">Get messages around snowflake.</param>
         private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
         {
-            if (this.Type != ChannelType.Text && this.Type != ChannelType.Private && this.Type != ChannelType.Group && this.Type != ChannelType.News)
+            if (!this.IsWriteable())
                 throw new ArgumentException("Cannot get the messages of a non-text channel.");
 
             if (limit < 0)
                 throw new ArgumentException("Cannot get a negative number of messages.");
 
             if (limit == 0)
                 return Array.Empty<DiscordMessage>();
 
             //return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
             if (limit > 100 && around != null)
                 throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
             var msgs = new List<DiscordMessage>(limit);
             var remaining = limit;
             ulong? last = null;
             var isAfter = after != null;
 
             int lastCount;
             do
             {
                 var fetchSize = remaining > 100 ? 100 : remaining;
                 var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
                 lastCount = fetch.Count;
                 remaining -= lastCount;
 
                 if (!isAfter)
                 {
                     msgs.AddRange(fetch);
                     last = fetch.LastOrDefault()?.Id;
                 }
                 else
                 {
                     msgs.InsertRange(0, fetch);
                     last = fetch.FirstOrDefault()?.Id;
                 }
             }
             while (remaining > 0 && lastCount > 0);
 
             return new ReadOnlyCollection<DiscordMessage>(msgs);
         }
 
         /// <summary>
         /// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="BadRequestException"/> error.
         /// </summary>
         /// <param name="messages">A collection of messages to delete.</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 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 DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
         {
             // don't enumerate more than once
             var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
             if (messages == null || !msgs.Any())
                 throw new ArgumentException("You need to specify at least one message to delete.");
 
             if (msgs.Count() < 2)
             {
                 await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
                 return;
             }
 
             for (var i = 0; i < msgs.Count(); i += 100)
                 await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a message
         /// </summary>
         /// <param name="message">The message to be deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> 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 DeleteMessageAsync(DiscordMessage message, string reason = null)
             => this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
         /// <summary>
         /// Returns a list of invite objects
         /// </summary>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> 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<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
         {
             return this.Guild == null
                 ? throw new ArgumentException("Cannot get the invites of a channel that does not belong to a guild.")
                 : this.Discord.ApiClient.GetChannelInvitesAsync(this.Id);
         }
 
         /// <summary>
         /// Create a new invite object
         /// </summary>
         /// <param name="max_age">Duration of invite in seconds before expiry, or 0 for never.  Defaults to 86400.</param>
         /// <param name="max_uses">Max number of uses or 0 for unlimited.  Defaults to 0</param>
 
         /// <param name="temporary">Whether this invite only grants temporary membership.  Defaults to false.</param>
         /// <param name="unique">If true, don't try to reuse a similar invite (useful for creating many unique one time use invites)</param>
         /// <param name="target_type">Target type of invite for the channel.  Defaults to Streaming</param>
         /// <param name="target_application">Target application of invite for the channel.  Defaults to None</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> 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<DiscordInvite> CreateInviteAsync(int max_age = 86400, int max_uses = 0, bool temporary = false, bool unique = false, TargetType? target_type = null, TargetActivity? target_application = null, string reason = null)
             => this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, max_age, max_uses, target_type, target_application, temporary, unique, reason);
 
         #region Stage
 
         /// <summary>
         /// Opens a stage.
         /// </summary>
         /// <param name="topic">Topic of the stage.</param>
         /// <param name="send_start_notification">Whether @everyone should be notified.</param>
         /// <param name="privacy_level">Privacy level of the stage (Defaults to <see cref="StagePrivacyLevel.GUILD_ONLY"/>.</param>
         /// <param name="reason">Audit log reason.</param>
         /// <returns>Stage instance</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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 async Task<DiscordStageInstance> OpenStageAsync(string topic, bool send_start_notification = false, StagePrivacyLevel privacy_level = StagePrivacyLevel.GUILD_ONLY, string reason = null)
             => await this.Discord.ApiClient.CreateStageInstanceAsync(this.Id, topic, send_start_notification, privacy_level, reason);
 
         /// <summary>
         /// Modifies a stage topic.
         /// </summary>
         /// <param name="topic">New topic of the stage.</param>
         /// <param name="privacy_level">New privacy level of the stage.</param>
         /// <param name="reason">Audit log reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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 async Task ModifyStageAsync(Optional<string> topic, Optional<StagePrivacyLevel> privacy_level, string reason = null)
             => await this.Discord.ApiClient.ModifyStageInstanceAsync(this.Id, topic, privacy_level, reason);
 
         /// <summary>
         /// Closes a stage.
         /// </summary>
         /// <param name="reason">Audit log reason.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> 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 async Task CloseStageAsync(string reason = null)
             => await this.Discord.ApiClient.DeleteStageInstanceAsync(this.Id, reason);
 
         /// <summary>
         /// Gets a stage.
         /// </summary>
         /// <returns>The requested stage.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or <see cref="Permissions.UseVoice"/> 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 async Task<DiscordStageInstance> GetStageAsync()
             => await this.Discord.ApiClient.GetStageInstanceAsync(this.Id);
 
         #endregion
 
         #region Threads
 
         /// <summary>
         /// Creates a thread.
         /// Depending on whether it is created inside an <see cref="ChannelType.News"/> or an <see cref="ChannelType.Text"/> it is either an <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.
         /// Depending on whether the <see cref="ChannelType"/> is set to <see cref="ChannelType.PrivateThread"/> it is either an <see cref="ChannelType.PrivateThread"/> or an <see cref="ChannelType.PublicThread"/> (default).
         /// </summary>
         /// <param name="name">The name of the thread.</param>
         /// <param name="auto_archive_duration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/>.</param>
         /// <param name="type">Can be either an <see cref="ChannelType.PrivateThread"/>, <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.</param>
         /// <param name="reason">Audit log reason.</param>
         /// <returns>The created thread.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePublicThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> or if creating a private thread the <see cref="Permissions.CreatePrivateThreads"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the guild hasn't enabled threads atm.</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. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>. Or if <see cref="GuildFeatures.CanCreatePrivateThreads"/> is not enabled for guild. This happens, if the guild does not have <see cref="PremiumTier.Tier_2"/></exception>
         public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration auto_archive_duration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, string reason = null)
         {
             return (type != ChannelType.NewsThread && type != ChannelType.PublicThread && type != ChannelType.PrivateThread)
                 ? throw new NotSupportedException("Wrong thread type given.")
-                : (this.Type != ChannelType.News && this.Type != ChannelType.Text)
-                ? throw new NotSupportedException("Parent channel is no text or news channel")
+                : (!this.IsThreadHolder())
+                ? throw new NotSupportedException("Parent channel can't have threads")
                 : type == ChannelType.PrivateThread
                 ? Utilities.CheckThreadPrivateFeature(this.Guild)
                 ? Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, auto_archive_duration)
                     ? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, auto_archive_duration, type, reason)
                     : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(auto_archive_duration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.")
                 : throw new NotSupportedException($"Cannot create a private thread. Guild needs to be boost tier two.")
                 : Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, auto_archive_duration)
                     ? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, auto_archive_duration, this.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, reason)
                 : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(auto_archive_duration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
         }
 
 
         /// <summary>
         /// Gets joined archived private threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <param name="before">Get threads created before this thread id.</param>
         /// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> 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 async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong? before, int? limit)
             => await this.Discord.ApiClient.GetJoinedPrivateArchivedThreadsAsync(this.Id, before, limit);
 
         /// <summary>
         /// Gets archived public threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <param name="before">Get threads created before this thread id.</param>
         /// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> 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 async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong? before, int? limit)
             => await this.Discord.ApiClient.GetPublicArchivedThreadsAsync(this.Id, before, limit);
 
         /// <summary>
         /// Gets archived private threads. Can contain more threads.
         /// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
         /// </summary>
         /// <param name="before">Get threads created before this thread id.</param>
         /// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> or <see cref="Permissions.ReadMessageHistory"/> 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 async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong? before, int? limit)
             => await this.Discord.ApiClient.GetPrivateArchivedThreadsAsync(this.Id, before, limit);
 
         #endregion
 
         /// <summary>
         /// Adds a channel permission overwrite for specified role.
         /// </summary>
         /// <param name="role">The role to have the permission added.</param>
         /// <param name="allow">The permissions to allow.</param>
         /// <param name="deny">The permissions to deny.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 AddOverwriteAsync(DiscordRole role, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
             => this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, role.Id, allow, deny, "role", reason);
 
 
         /// <summary>
         /// Adds a channel permission overwrite for specified member.
         /// </summary>
         /// <param name="member">The member to have the permission added.</param>
         /// <param name="allow">The permissions to allow.</param>
         /// <param name="deny">The permissions to deny.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 AddOverwriteAsync(DiscordMember member, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
             => this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, member.Id, allow, deny, "member", reason);
 
         /// <summary>
         /// Deletes a channel permission overwrite for specified member.
         /// </summary>
         /// <param name="member">The member to have the permission deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 DeleteOverwriteAsync(DiscordMember member, string reason = null)
             => this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, member.Id, reason);
 
         /// <summary>
         /// Deletes a channel permission overwrite for specified role.
         /// </summary>
         /// <param name="role">The role to have the permission deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> 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 DeleteOverwriteAsync(DiscordRole role, string reason = null)
             => this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, role.Id, reason);
 
         /// <summary>
         /// Post a typing indicator
         /// </summary>
 
         /// <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 TriggerTypingAsync()
         {
-            return this.Type != ChannelType.Text && this.Type != ChannelType.Private && this.Type != ChannelType.Group && this.Type != ChannelType.News
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot start typing in a non-text channel.")
                 : this.Discord.ApiClient.TriggerTypingAsync(this.Id);
         }
 
         /// <summary>
         /// Returns all pinned messages
         /// </summary>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> 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<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync()
         {
-            return this.Type != ChannelType.Text && this.Type != ChannelType.Private && this.Type != ChannelType.Group && this.Type != ChannelType.News
+            return !this.IsWriteable()
                 ? throw new ArgumentException("A non-text channel does not have pinned messages.")
                 : this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
         }
 
         /// <summary>
         /// Create a new webhook
         /// </summary>
         /// <param name="name">The name of the webhook.</param>
         /// <param name="avatar">The image for the default webhook avatar.</param>
         /// <param name="reason">Reason for audit logs.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> 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 async Task<DiscordWebhook> CreateWebhookAsync(string name, Optional<Stream> avatar = default, string reason = null)
         {
             var av64 = Optional.FromNoValue<string>();
             if (avatar.HasValue && avatar.Value != null)
                 using (var imgtool = new ImageTool(avatar.Value))
                     av64 = imgtool.GetBase64();
             else if (avatar.HasValue)
                 av64 = null;
 
             return await this.Discord.ApiClient.CreateWebhookAsync(this.Id, name, av64, reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a list of webhooks
         /// </summary>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the channel does not exist.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
             => this.Discord.ApiClient.GetChannelWebhooksAsync(this.Id);
 
         /// <summary>
         /// Moves a member to this voice channel
         /// </summary>
         /// <param name="member">The member to be moved.</param>
 
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the channel does not exists or if the Member 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 async Task PlaceMemberAsync(DiscordMember member)
         {
-            if (this.Type != ChannelType.Voice && this.Type != ChannelType.Stage)
-                throw new ArgumentException("Cannot place a member in a non-voice channel!"); // be a little more angry, let em learn!!1
+            if (!this.IsVoiceJoinable())
+                throw new ArgumentException("Cannot place a member in a non-voice channel.");
 
             await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, member.Id, default, default, default,
                 default, this.Id, null).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Follows a news channel
         /// </summary>
         /// <param name="targetChannel">Channel to crosspost messages to</param>
         /// <exception cref="ArgumentException">Thrown when trying to follow a non-news channel</exception>
         /// <exception cref="UnauthorizedException">Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> on the target channel</exception>
         public Task<DiscordFollowedChannel> FollowAsync(DiscordChannel targetChannel)
         {
             return this.Type != ChannelType.News
                 ? throw new ArgumentException("Cannot follow a non-news channel.")
                 : this.Discord.ApiClient.FollowChannelAsync(this.Id, targetChannel.Id);
         }
 
         /// <summary>
         /// Publishes a message in a news channel to following channels
         /// </summary>
         /// <param name="message">Message to publish</param>
         /// <exception cref="ArgumentException">Thrown when the message has already been crossposted</exception>
         /// <exception cref="UnauthorizedException">
         ///     Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> and/or <see cref="Permissions.SendMessages"/>
         /// </exception>
         public Task<DiscordMessage> CrosspostMessageAsync(DiscordMessage message)
         {
             return (message.Flags & MessageFlags.Crossposted) == MessageFlags.Crossposted
                 ? throw new ArgumentException("Message is already crossposted.")
                 : this.Discord.ApiClient.CrosspostMessageAsync(this.Id, message.Id);
         }
 
         /// <summary>
         /// Updates the current user's suppress state in this channel, if stage channel.
         /// </summary>
         /// <param name="suppress">Toggles the suppress state.</param>
         /// <param name="requestToSpeakTimestamp">Sets the time the user requested to speak.</param>
         /// <exception cref="ArgumentException">Thrown when the channel is not a stage channel.</exception>
         public async Task UpdateCurrentUserVoiceStateAsync(bool? suppress, DateTimeOffset? requestToSpeakTimestamp = null)
         {
             if (this.Type != ChannelType.Stage)
                 throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
             await this.Discord.ApiClient.UpdateCurrentUserVoiceStateAsync(this.GuildId.Value, this.Id, suppress, requestToSpeakTimestamp).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Calculates permissions for a given member.
         /// </summary>
         /// <param name="mbr">Member to calculate permissions for.</param>
         /// <returns>Calculated permissions for a given member.</returns>
         public Permissions PermissionsFor(DiscordMember mbr)
         {
             // future note: might be able to simplify @everyone role checks to just check any role ... but I'm not sure
             // xoxo, ~uwx
             //
             // you should use a single tilde
             // ~emzi
 
             // user > role > everyone
             // allow > deny > undefined
             // =>
             // user allow > user deny > role allow > role deny > everyone allow > everyone deny
             // thanks to meew0
 
             if (this.IsPrivate || this.Guild == null)
                 return Permissions.None;
 
             if (this.Guild.OwnerId == mbr.Id)
                 return PermissionMethods.FULL_PERMS;
 
             Permissions perms;
 
             // assign @everyone permissions
             var everyoneRole = this.Guild.EveryoneRole;
             perms = everyoneRole.Permissions;
 
             // roles that member is in
             var mbRoles = mbr.Roles.Where(xr => xr.Id != everyoneRole.Id).ToArray();
 
             // assign permissions from member's roles (in order)
             perms |= mbRoles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
             // Adminstrator grants all permissions and cannot be overridden
             if ((perms & Permissions.Administrator) == Permissions.Administrator)
                 return PermissionMethods.FULL_PERMS;
 
             // channel overrides for roles that member is in
             var mbRoleOverrides = mbRoles
                 .Select(xr => this._permissionOverwrites.FirstOrDefault(xo => xo.Id == xr.Id))
                 .Where(xo => xo != null)
                 .ToList();
 
             // assign channel permission overwrites for @everyone pseudo-role
             var everyoneOverwrites = this._permissionOverwrites.FirstOrDefault(xo => xo.Id == everyoneRole.Id);
             if (everyoneOverwrites != null)
             {
                 perms &= ~everyoneOverwrites.Denied;
                 perms |= everyoneOverwrites.Allowed;
             }
 
             // assign channel permission overwrites for member's roles (explicit deny)
             perms &= ~mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Denied);
             // assign channel permission overwrites for member's roles (explicit allow)
             perms |= mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Allowed);
 
             // channel overrides for just this member
             var mbOverrides = this._permissionOverwrites.FirstOrDefault(xo => xo.Id == mbr.Id);
             if (mbOverrides == null) return perms;
 
             // assign channel permission overwrites for just this member
             perms &= ~mbOverrides.Denied;
             perms |= mbOverrides.Allowed;
 
             return perms;
         }
 
         /// <summary>
         /// Returns a string representation of this channel.
         /// </summary>
         /// <returns>String representation of this channel.</returns>
         public override string ToString()
         {
             return this.Type == ChannelType.Category
                 ? $"Channel Category {this.Name} ({this.Id})"
-                : this.Type == ChannelType.Text || this.Type == ChannelType.News
+                : this.Type == ChannelType.Text || this.Type == ChannelType.News || this.IsThread()
                 ? $"Channel #{this.Name} ({this.Id})"
+                : this.IsVoiceJoinable()
+                ? $"Channel #!{this.Name} ({this.Id})"
                 : !string.IsNullOrWhiteSpace(this.Name) ? $"Channel {this.Name} ({this.Id})" : $"Channel {this.Id}";
         }
         #endregion
 
         /// <summary>
         /// Checks whether this <see cref="DiscordChannel"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordChannel"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordChannel);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordChannel"/> is equal to another <see cref="DiscordChannel"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordChannel"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordChannel"/> is equal to this <see cref="DiscordChannel"/>.</returns>
         public bool Equals(DiscordChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordChannel"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordChannel"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordChannel"/> objects are equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are equal.</returns>
         public static bool operator ==(DiscordChannel e1, DiscordChannel e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordChannel"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are not equal.</returns>
         public static bool operator !=(DiscordChannel e1, DiscordChannel e2)
             => !(e1 == e2);
     }
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
index 82ffa762b..bcb7a6a4d 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
@@ -1,659 +1,661 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a discord thread channel.
     /// </summary>
     public class DiscordThreadChannel : DiscordChannel, IEquatable<DiscordThreadChannel>
     {
         /// <summary>
         /// Gets ID of the owner that started this thread.
         /// </summary>
         [JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
         public ulong OwnerId { get; internal set; }
 
         /// <summary>
         /// Gets the name of this thread.
         /// </summary>
         [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
         public new string Name { get; internal set; }
 
         /// <summary>
         /// Gets the type of this thread.
         /// </summary>
         [JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
         public new ChannelType Type { get; internal set; }
 
         /// <summary>
         /// Gets whether this thread is private.
         /// </summary>
         [JsonIgnore]
         public new bool IsPrivate
             => this.Type == ChannelType.PrivateThread;
 
         /// <summary>
         /// Gets the ID of the last message sent in this thread.
         /// </summary>
         [JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
         public new ulong? LastMessageId { get; internal set; }
 
         /// <summary>
         /// <para>Gets the slowmode delay configured for this thread.</para>
         /// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slowmode.</para>
         /// </summary>
         [JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
         public new int? PerUserRateLimit { get; internal set; }
 
         /// <summary>
         /// Gets an approximate count of messages in a thread, stops counting at 50.
         /// </summary>
         [JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? MessageCount { get; internal set; }
 
         /// <summary>
         /// Gets an approximate count of users in a thread, stops counting at 50.
         /// </summary>
         [JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
         public int? MemberCount { get; internal set; }
 
         /// <summary>
         /// Represents the current member for this thread. This will have a value if the user has joined the thread.
         /// </summary>
         [JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordThreadChannelMember CurrentMember { get; internal set; }
 
 
         /// <summary>
         /// Gets when the last pinned message was pinned in this thread.
         /// </summary>
         [JsonIgnore]
         public new DateTimeOffset? LastPinTimestamp
             => !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
                 dto : null;
 
         /// <summary>
         /// Gets when the last pinned message was pinned in this thread as raw string.
         /// </summary>
         [JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
         internal new string LastPinTimestampRaw { get; set; }
 
         /// <summary>
         /// Gets the threads metadata.
         /// </summary>
         [JsonProperty("thread_metadata", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordThreadChannelMetadata ThreadMetadata { get; internal set; }
 
         /// <summary>
         /// Gets the thread members object.
         /// </summary>
         [JsonIgnore]
         public IReadOnlyDictionary<ulong, DiscordThreadChannelMember> ThreadMembers => new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannelMember>(this._threadMembers);
 
         [JsonProperty("thread_member", NullValueHandling = NullValueHandling.Ignore)]
         [JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
         internal ConcurrentDictionary<ulong, DiscordThreadChannelMember> _threadMembers;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
         /// </summary>
         internal DiscordThreadChannel() { }
 
         #region Methods
 
         /// <summary>
         /// Deletes a thread.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
         /// <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 new Task DeleteAsync(string reason = null)
             => this.Discord.ApiClient.DeleteThreadAsync(this.Id, reason);
 
 
         /// <summary>
         /// Modifies the current thread.
         /// </summary>
         /// <param name="action">Action to perform on this thread</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
         /// <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>
         /// <exception cref="NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>.</exception>
         public Task ModifyAsync(Action<ThreadEditModel> action)
         {
             var mdl = new ThreadEditModel();
             action(mdl);
 
             var can_continue = !mdl.AutoArchiveDuration.HasValue || !mdl.AutoArchiveDuration.Value.HasValue || Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.AutoArchiveDuration.Value.Value);
             if (mdl.Invitable.HasValue)
             {
                 can_continue = this.Guild.Features.CanCreatePrivateThreads;
             }
             return can_continue ? this.Discord.ApiClient.ModifyThreadAsync(this.Id, mdl.Name, mdl.Locked, mdl.Archived, mdl.AutoArchiveDuration, mdl.PerUserRateLimit, mdl.Invitable, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(mdl.AutoArchiveDuration.Value.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
         }
 
         /// <summary>
         /// Archives a thread.
         /// </summary>
         /// <param name="locked">Whether the thread should be locked.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task ArchiveAsync(bool locked = true, string reason = null)
             => this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, locked, true, null, null, null, reason: reason);
 
         /// <summary>
         /// Unarchives a thread.
         /// </summary>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task UnarchiveAsync(string reason = null)
             => this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, null, false, null, null, null, reason: reason);
 
         /// <summary>
         /// Gets the members of a thread. Needs the <see cref="DiscordIntents.GuildMembers"/> intent.
         /// </summary>
         /// <exception cref="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<IReadOnlyList<DiscordThreadChannelMember>> GetMembersAsync()
             => await this.Discord.ApiClient.GetThreadMembersAsync(this.Id);
 
         /// <summary>
         /// Adds a member to this thread.
         /// </summary>
         /// <param name="member_id">The member id to be added.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddMemberAsync(ulong member_id)
             => this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member_id);
 
         /// <summary>
         /// Adds a member to this thread.
         /// </summary>
         /// <param name="member">The member to be added.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddMemberAsync(DiscordMember member)
             => this.AddMemberAsync(member.Id);
 
         /// <summary>
         /// Gets a member in this thread.
         /// </summary>
         /// <param name="member_id">The member to be added.</param>
         /// <exception cref="NotFoundException">Thrown when the member is not part of the thread.</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<DiscordThreadChannelMember> GetMemberAsync(ulong member_id)
             => this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member_id);
 
         /// <summary>
         /// Gets a member in this thread.
         /// </summary>
         /// <param name="member">The member to be added.</param>
         /// <exception cref="NotFoundException">Thrown when the member is not part of the thread.</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<DiscordThreadChannelMember> GetMemberAsync(DiscordMember member)
             => this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member.Id);
 
         /// <summary>
         /// Removes a member from this thread.
         /// </summary>
         /// <param name="member_id">The member id to be removed.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveMemberAsync(ulong member_id)
             => this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member_id);
 
         /// <summary>
         /// Removes a member from this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="member">The member to be removed.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveMemberAsync(DiscordMember member)
             => this.RemoveMemberAsync(member.Id);
 
         /// <summary>
         /// Adds a role to this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role_id">The role id to be added.</param>
         /// <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 AddRoleAsync(ulong role_id)
         {
             var role = this.Guild.GetRole(role_id);
             var members = await this.Guild.GetAllMembersAsync();
             var roleMembers = members.Where(m => m.Roles.Contains(role));
             foreach(var member in roleMembers)
             {
                 await this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member.Id);
             }
         }
 
         /// <summary>
         /// Adds a role to this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role">The role to be added.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task AddRoleAsync(DiscordRole role)
             => this.AddRoleAsync(role.Id);
 
         /// <summary>
         /// Removes a role from this thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role_id">The role id to be removed.</param>
         /// <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 RemoveRoleAsync(ulong role_id)
         {
             var role = this.Guild.GetRole(role_id);
             var members = await this.Guild.GetAllMembersAsync();
             var roleMembers = members.Where(m => m.Roles.Contains(role));
             foreach (var member in roleMembers)
             {
                 await this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member.Id);
             }
         }
 
         /// <summary>
         /// Removes a role to from thread. Only applicable to private threads.
         /// </summary>
         /// <param name="role">The role to be removed.</param>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task RemoveRoleAsync(DiscordRole role)
             => this.RemoveRoleAsync(role.Id);
 
         /// <summary>
         /// Joins a thread.
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client has no access to this thread.</exception>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task JoinAsync()
             => this.Discord.ApiClient.JoinThreadAsync(this.Id);
 
         /// <summary>
         /// Leaves a thread.
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client has no access to this thread.</exception>
         /// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
         /// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
         /// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
         public Task LeaveAsync()
             => this.Discord.ApiClient.LeaveThreadAsync(this.Id);
 
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
         /// <exception cref="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 new Task<DiscordMessage> SendMessageAsync(string content)
         {
-            return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
         /// <exception cref="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 new Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
         {
-            return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, null, new[] {embed}, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="content">Content of the message to send.</param>
         /// <param name="embed">Embed to attach to the message.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
         /// <exception cref="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 new Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
         {
-            return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
+            return !this.IsWriteable()
                 ? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
                 : this.Discord.ApiClient.CreateMessageAsync(this.Id, content, new[] {embed}, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
         }
 
         /// <summary>
         /// Sends a message to this thread.
         /// </summary>
         /// <param name="builder">The builder with all the items to thread.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
         /// <exception cref="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 new Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
             => this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
         /// <summary>
         /// Sends a message to this channel.
         /// </summary>
         /// <param name="action">The builder with all the items to send.</param>
         /// <returns>The sent message.</returns>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
         /// <exception cref="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 new Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
         {
             var builder = new DiscordMessageBuilder();
             action(builder);
 
-            return this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
+            return !this.IsWriteable()
+                ? throw new ArgumentException("Cannot send a text message to a non-text channel.")
+                : this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
         }
 
         /// <summary>
         /// Returns a specific message
         /// </summary>
         /// <param name="id">The id of the message</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
         /// <exception cref="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 new async Task<DiscordMessage> GetMessageAsync(ulong id)
         {
             return this.Discord.Configuration.MessageCacheSize > 0
                 && this.Discord is DiscordClient dc
                 && dc.MessageCache != null
                 && dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
                 ? msg
                 : await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a list of messages before a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="before">Message to fetch before from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
         /// <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 new Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
             => this.GetMessagesInternalAsync(limit, before, null, null);
 
         /// <summary>
         /// Returns a list of messages after a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="after">Message to fetch after from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
         /// <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 new Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, after, null);
 
         /// <summary>
         /// Returns a list of messages around a certain message.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// <param name="around">Message to fetch around from.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
         /// <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 new Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
             => this.GetMessagesInternalAsync(limit, null, null, around);
 
         /// <summary>
         /// Returns a list of messages from the last message in the thread.
         /// <param name="limit">The amount of messages to fetch.</param>
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
         /// <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 new Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
             this.GetMessagesInternalAsync(limit, null, null, null);
 
         /// <summary>
         /// Returns a list of messages
         /// </summary>
         /// <param name="limit">How many messages should be returned.</param>
         /// <param name="before">Get messages before snowflake.</param>
         /// <param name="after">Get messages after snowflake.</param>
         /// <param name="around">Get messages around snowflake.</param>
         private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
         {
             if (this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread)
                 throw new ArgumentException("Cannot get the messages of a non-thread channel.");
 
             if (limit < 0)
                 throw new ArgumentException("Cannot get a negative number of messages.");
 
             if (limit == 0)
                 return Array.Empty<DiscordMessage>();
 
             //return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
             if (limit > 100 && around != null)
                 throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
             var msgs = new List<DiscordMessage>(limit);
             var remaining = limit;
             ulong? last = null;
             var isAfter = after != null;
 
             int lastCount;
             do
             {
                 var fetchSize = remaining > 100 ? 100 : remaining;
                 var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
                 lastCount = fetch.Count;
                 remaining -= lastCount;
 
                 if (!isAfter)
                 {
                     msgs.AddRange(fetch);
                     last = fetch.LastOrDefault()?.Id;
                 }
                 else
                 {
                     msgs.InsertRange(0, fetch);
                     last = fetch.FirstOrDefault()?.Id;
                 }
             }
             while (remaining > 0 && lastCount > 0);
 
             return new ReadOnlyCollection<DiscordMessage>(msgs);
         }
 
         /// <summary>
         /// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="BadRequestException"/> error.
         /// </summary>
         /// <param name="messages">A collection of messages to delete.</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 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 new async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
         {
             // don't enumerate more than once
             var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
             if (messages == null || !msgs.Any())
                 throw new ArgumentException("You need to specify at least one message to delete.");
 
             if (msgs.Count() < 2)
             {
                 await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
                 return;
             }
 
             for (var i = 0; i < msgs.Count(); i += 100)
                 await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a message
         /// </summary>
         /// <param name="message">The message to be deleted.</param>
         /// <param name="reason">Reason for audit logs.</param>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
         /// <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 new Task DeleteMessageAsync(DiscordMessage message, string reason = null)
             => this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 
         /// <summary>
         /// Post a typing indicator
         /// </summary>
         /// <exception cref="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 new Task TriggerTypingAsync()
         {
             return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
                 ? throw new ArgumentException("Cannot start typing in a non-text channel.")
                 : this.Discord.ApiClient.TriggerTypingAsync(this.Id);
         }
 
         /// <summary>
         /// Returns all pinned messages
         /// </summary>
         /// <exception cref="UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission or the client is missing <see cref="Permissions.ReadMessageHistory"/>.</exception>
         /// <exception cref="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 new Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync()
         {
             return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread&& this.Type != ChannelType.News
                 ? throw new ArgumentException("A non-thread channel does not have pinned messages.")
                 : this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
         }
 
         /// <summary>
         /// Returns a string representation of this thread.
         /// </summary>
         /// <returns>String representation of this thread.</returns>
         public override string ToString()
         {
             var threadchannel = (object)this.Type switch
             {
                 ChannelType.NewsThread => $"News thread {this.Name} ({this.Id})",
                 ChannelType.PublicThread => $"Thread {this.Name} ({this.Id})",
                 ChannelType.PrivateThread => $"Private thread {this.Name} ({this.Id})",
                 _ => $"Thread {this.Name} ({this.Id})",
             };
             return threadchannel;
         }
         #endregion
 
         /// <summary>
         /// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another object.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether the object is equal to this <see cref="DiscordThreadChannel"/>.</returns>
         public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannel);
 
         /// <summary>
         /// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannel"/>.
         /// </summary>
         /// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
         /// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannel"/>.</returns>
         public bool Equals(DiscordThreadChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
         /// <summary>
         /// Gets the hash code for this <see cref="DiscordThreadChannel"/>.
         /// </summary>
         /// <returns>The hash code for this <see cref="DiscordThreadChannel"/>.</returns>
         public override int GetHashCode() => this.Id.GetHashCode();
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are equal.</returns>
         public static bool operator ==(DiscordThreadChannel e1, DiscordThreadChannel e2)
         {
             var o1 = e1 as object;
             var o2 = e2 as object;
 
             return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
         }
 
         /// <summary>
         /// Gets whether the two <see cref="DiscordThreadChannel"/> objects are not equal.
         /// </summary>
         /// <param name="e1">First channel to compare.</param>
         /// <param name="e2">Second channel to compare.</param>
         /// <returns>Whether the two channels are not equal.</returns>
         public static bool operator !=(DiscordThreadChannel e1, DiscordThreadChannel e2)
             => !(e1 == e2);
     }
 }
diff --git a/DisCatSharp/Entities/User/DiscordTeam.cs b/DisCatSharp/Entities/User/DiscordTeam.cs
index 6cfa6ec83..7a51a33d8 100644
--- a/DisCatSharp/Entities/User/DiscordTeam.cs
+++ b/DisCatSharp/Entities/User/DiscordTeam.cs
@@ -1,203 +1,197 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents a team consisting of users. A team can own an application.
     /// </summary>
     public sealed class DiscordTeam : SnowflakeObject, IEquatable<DiscordTeam>
     {
         /// <summary>
         /// Gets the team's name.
         /// </summary>
         public string Name { get; internal set; }
 
         /// <summary>
         /// Gets the team's icon hash.
         /// </summary>
         public string IconHash { get; internal set; }
 
         /// <summary>
         /// Gets the team's icon.
         /// </summary>
         public string Icon
             => !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.TEAM_ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.png?size=1024" : null;
 
         /// <summary>
         /// Gets the owner of the team.
         /// </summary>
         public DiscordUser Owner { get; internal set; }
 
         /// <summary>
         /// Gets the members of this team.
         /// </summary>
         public IReadOnlyList<DiscordTeamMember> Members { get; internal set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordTeam"/> class.
         /// </summary>
         /// <param name="tt">The tt.</param>
         internal DiscordTeam(TransportTeam tt)
         {
             this.Id = tt.Id;
             this.Name = tt.Name;
             this.IconHash = tt.IconHash;
         }
 
         /// <summary>
         /// Compares this team to another object and returns whether they are equal.
         /// </summary>
         /// <param name="obj">Object to compare this team to.</param>
         /// <returns>Whether this team is equal to the given object.</returns>
         public override bool Equals(object obj)
             => obj is DiscordTeam other && this == other;
 
         /// <summary>
         /// Compares this team to another team and returns whether they are equal.
         /// </summary>
         /// <param name="other">Team to compare to.</param>
         /// <returns>Whether the teams are equal.</returns>
         public bool Equals(DiscordTeam other)
             => this == other;
 
         /// <summary>
         /// Gets the hash code of this team.
         /// </summary>
         /// <returns>Hash code of this team.</returns>
         public override int GetHashCode()
             => this.Id.GetHashCode();
 
         /// <summary>
         /// Converts this team to its string representation.
         /// </summary>
         /// <returns>The string representation of this team.</returns>
         public override string ToString()
             => $"Team: {this.Name} ({this.Id})";
 
         public static bool operator ==(DiscordTeam left, DiscordTeam right)
             => left?.Id == right?.Id;
 
         public static bool operator !=(DiscordTeam left, DiscordTeam right)
             => left?.Id != right?.Id;
     }
 
     /// <summary>
     /// Represents a member of <see cref="DiscordTeam"/>.
     /// </summary>
     public sealed class DiscordTeamMember : IEquatable<DiscordTeamMember>
     {
         /// <summary>
         /// Gets the member's membership status.
         /// </summary>
         public DiscordTeamMembershipStatus MembershipStatus { get; internal set; }
 
         /// <summary>
         /// Gets the member's permissions within the team.
         /// </summary>
         public IReadOnlyCollection<string> Permissions { get; internal set; }
 
         /// <summary>
         /// Gets the team this member belongs to.
         /// </summary>
         public DiscordTeam Team { get; internal set; }
 
         /// <summary>
         /// Gets the user who is the team member.
         /// </summary>
         public DiscordUser User { get; internal set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordTeamMember"/> class.
         /// </summary>
         /// <param name="ttm">The ttm.</param>
         internal DiscordTeamMember(TransportTeamMember ttm)
         {
             this.MembershipStatus = (DiscordTeamMembershipStatus)ttm.MembershipState;
             this.Permissions = new ReadOnlySet<string>(new HashSet<string>(ttm.Permissions));
         }
 
         /// <summary>
         /// Compares this team member to another object and returns whether they are equal.
         /// </summary>
         /// <param name="obj">Object to compare to.</param>
         /// <returns>Whether this team is equal to given object.</returns>
         public override bool Equals(object obj)
             => obj is DiscordTeamMember other && this == other;
 
         /// <summary>
         /// Compares this team member to another team member and returns whether they are equal.
         /// </summary>
         /// <param name="other">Team member to compare to.</param>
         /// <returns>Whether this team member is equal to the given one.</returns>
         public bool Equals(DiscordTeamMember other)
             => this == other;
 
         /// <summary>
         /// Gets a hash code of this team member.
         /// </summary>
         /// <returns>Hash code of this team member.</returns>
-        public override int GetHashCode()
-        {
-            var hash = 13;
-            hash = (hash * 7) + this.User.GetHashCode();
-            hash = (hash * 7) + this.Team.GetHashCode();
-            return hash;
-        }
+        public override int GetHashCode() => HashCode.Combine(this.User, this.Team);
 
         /// <summary>
         /// Converts this team member to their string representation.
         /// </summary>
         /// <returns>String representation of this team member.</returns>
         public override string ToString()
             => $"Team member: {this.User.Username}#{this.User.Discriminator} ({this.User.Id}), part of team {this.Team.Name} ({this.Team.Id})";
 
         public static bool operator ==(DiscordTeamMember left, DiscordTeamMember right)
             => left?.Team?.Id == right?.Team?.Id && left?.User?.Id == right?.User?.Id;
 
         public static bool operator !=(DiscordTeamMember left, DiscordTeamMember right)
             => left?.Team?.Id != right?.Team?.Id || left?.User?.Id != right?.User?.Id;
     }
 
     /// <summary>
     /// Signifies the status of user's team membership.
     /// </summary>
     public enum DiscordTeamMembershipStatus : int
     {
         /// <summary>
         /// Indicates that this user is invited to the team, and is pending membership.
         /// </summary>
         Invited = 1,
 
         /// <summary>
         /// Indicates that this user is a member of the team.
         /// </summary>
         Accepted = 2
     }
 }
diff --git a/DisCatSharp/GlobalSuppressions.cs b/DisCatSharp/GlobalSuppressions.cs
index d7a572b96..61cb29272 100644
--- a/DisCatSharp/GlobalSuppressions.cs
+++ b/DisCatSharp/GlobalSuppressions.cs
@@ -1,34 +1,36 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Diagnostics.CodeAnalysis;
 
 [assembly: SuppressMessage("Style", "IDE0046:Convert to conditional expression", Justification = "<Pending>", Scope = "member", Target = "~P:DisCatSharp.Net.Abstractions.ClientProperties.OperatingSystem")]
 [assembly: SuppressMessage("CodeQuality", "IDE0079:Remove unnecessary suppression", Justification = "<Pending>")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordUnicodeEmoji._1SkinTone1")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordUnicodeEmoji._1SkinTone2")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordUnicodeEmoji._1SkinTone3")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordUnicodeEmoji._1SkinTone4")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordUnicodeEmoji._1SkinTone5")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordUnicodeEmoji._8ball")]
 [assembly: SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordColor.HexAlphabet")]
 [assembly: SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.Entities.DiscordColor.HexAlphabet")]
+[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~P:DisCatSharp.Internals.PermissionStrings")]
+[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "member", Target = "~P:DisCatSharp.Internals.VersionHeader")]
diff --git a/DisCatSharp/Internals.cs b/DisCatSharp/Internals.cs
new file mode 100644
index 000000000..2be336bc0
--- /dev/null
+++ b/DisCatSharp/Internals.cs
@@ -0,0 +1,101 @@
+// This file is part of the DisCatSharp project, a fork of DSharpPlus.
+//
+// Copyright (c) 2021 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using DisCatSharp.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace DisCatSharp
+{
+    /// <summary>
+    /// Internal tools.
+    /// </summary>
+    public static class Internals
+    {
+        /// <summary>
+        /// Gets the version of the library
+        /// </summary>
+        private static string VersionHeader
+            => Utilities.VersionHeader;
+
+        /// <summary>
+        /// Gets the permission strings.
+        /// </summary>
+        private static Dictionary<Permissions, string> PermissionStrings
+            => Utilities.PermissionStrings;
+
+        /// <summary>
+        /// Gets the utf8 encoding
+        /// </summary>
+        internal static UTF8Encoding UTF8
+            => Utilities.UTF8;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Internals"/> class.
+        /// </summary>
+        static Internals() { }
+
+        /// <summary>
+        /// Whether the <see cref="DiscordChannel"/> is joinable via voice.
+        /// </summary>
+        /// <param name="channel">The channel.</param>
+        internal static bool IsVoiceJoinable(this DiscordChannel channel) => channel.Type == ChannelType.Voice || channel.Type == ChannelType.Stage;
+
+        /// <summary>
+        /// Whether the <see cref="DiscordChannel"/> is related to threads.
+        /// </summary>
+        /// <param name="channel">The channel.</param>
+        internal static bool IsThreadHolder(this DiscordChannel channel) => channel.Type == ChannelType.Text || channel.Type == ChannelType.News || channel.Type == ChannelType.GuildForum;
+
+        /// <summary>
+        /// Whether the <see cref="DiscordChannel"/> is related to threads.
+        /// </summary>
+        /// <param name="channel">The channel.</param>
+        internal static bool IsThread(this DiscordChannel channel) => channel.Type == ChannelType.PublicThread || channel.Type == ChannelType.PrivateThread || channel.Type == ChannelType.NewsThread;
+
+        /// <summary>
+        /// Whether users can write the <see cref="DiscordChannel"/>.
+        /// </summary>
+        /// <param name="channel">The channel.</param>
+        internal static bool IsWriteable(this DiscordChannel channel) => channel.Type == ChannelType.PublicThread || channel.Type == ChannelType.PrivateThread || channel.Type == ChannelType.NewsThread || channel.Type == ChannelType.Text || channel.Type == ChannelType.News || channel.Type == ChannelType.Group || channel.Type == ChannelType.Private || channel.Type == ChannelType.Voice;
+
+        /// <summary>
+        /// Whether the <see cref="DiscordChannel"/> is moveable in a parent.
+        /// </summary>
+        /// <param name="channel">The channel.</param>
+        internal static bool IsMovableInParent(this DiscordChannel channel) => channel.Type == ChannelType.Voice || channel.Type == ChannelType.Stage || channel.Type == ChannelType.Text || channel.Type == ChannelType.GuildForum || channel.Type == ChannelType.News || channel.Type == ChannelType.Store;
+
+        /// <summary>
+        /// Whether the <see cref="DiscordChannel"/> is moveable in a parent.
+        /// </summary>
+        /// <param name="channel">The channel.</param>
+        internal static bool IsMovable (this DiscordChannel channel) => channel.Type == ChannelType.Voice || channel.Type == ChannelType.Stage || channel.Type == ChannelType.Text || channel.Type == ChannelType.Category || channel.Type == ChannelType.GuildForum || channel.Type == ChannelType.News || channel.Type == ChannelType.Store;
+    }
+}
diff --git a/DisCatSharp/Utilities.cs b/DisCatSharp/Utilities.cs
index b71af6e5f..a5891168c 100644
--- a/DisCatSharp/Utilities.cs
+++ b/DisCatSharp/Utilities.cs
@@ -1,465 +1,465 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Net;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
     /// <summary>
     /// Various Discord-related utilities.
     /// </summary>
     public static class Utilities
     {
         /// <summary>
         /// Gets the version of the library
         /// </summary>
-        private static string VersionHeader { get; set; }
+        internal static string VersionHeader { get; set; }
 
         /// <summary>
         /// Gets or sets the permission strings.
         /// </summary>
-        private static Dictionary<Permissions, string> PermissionStrings { get; set; }
+        internal static Dictionary<Permissions, string> PermissionStrings { get; set; }
 
         /// <summary>
         /// Gets the utf8 encoding
         /// </summary>
         internal static UTF8Encoding UTF8 { get; } = new UTF8Encoding(false);
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Utilities"/> class.
         /// </summary>
         static Utilities()
         {
             PermissionStrings = new Dictionary<Permissions, string>();
             var t = typeof(Permissions);
             var ti = t.GetTypeInfo();
             var vals = Enum.GetValues(t).Cast<Permissions>();
 
             foreach (var xv in vals)
             {
                 var xsv = xv.ToString();
                 var xmv = ti.DeclaredMembers.FirstOrDefault(xm => xm.Name == xsv);
                 var xav = xmv.GetCustomAttribute<PermissionStringAttribute>();
 
                 PermissionStrings[xv] = xav.String;
             }
 
             var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
             var vs = "";
             var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
             if (iv != null)
                 vs = iv.InformationalVersion;
             else
             {
                 var v = a.GetName().Version;
                 vs = v.ToString(3);
             }
 
             VersionHeader = $"DiscordBot (https://github.com/Aiko-IT-Systems/DisCatSharp, v{vs})";
         }
 
         /// <summary>
         /// Gets the api base uri.
         /// </summary>
         /// <param name="config">The config</param>
         /// <returns>A string.</returns>
         internal static string GetApiBaseUri(DiscordConfiguration config = null)
             => config == null ? Endpoints.BASE_URI + "9" : config.UseCanary ? Endpoints.CANARY_URI + config.ApiVersion : Endpoints.BASE_URI + config.ApiVersion;
 
         /// <summary>
         /// Gets the api uri for.
         /// </summary>
         /// <param name="path">The path.</param>
         /// <param name="config">The config</param>
         /// <returns>An Uri.</returns>
         internal static Uri GetApiUriFor(string path, DiscordConfiguration config)
             => new($"{GetApiBaseUri(config)}{path}");
 
         /// <summary>
         /// Gets the api uri for.
         /// </summary>
         /// <param name="path">The path.</param>
         /// <param name="queryString">The query string.</param>
         /// <param name="config">The config</param>
         /// <returns>An Uri.</returns>
         internal static Uri GetApiUriFor(string path, string queryString, DiscordConfiguration config)
             => new($"{GetApiBaseUri(config)}{path}{queryString}");
 
         /// <summary>
         /// Gets the api uri builder for.
         /// </summary>
         /// <param name="path">The path.</param>
         /// <param name="config">The config</param>
         /// <returns>A QueryUriBuilder.</returns>
         internal static QueryUriBuilder GetApiUriBuilderFor(string path, DiscordConfiguration config)
             => new($"{GetApiBaseUri(config)}{path}");
 
         /// <summary>
         /// Gets the formatted token.
         /// </summary>
         /// <param name="client">The client.</param>
         /// <returns>A string.</returns>
         internal static string GetFormattedToken(BaseDiscordClient client) => GetFormattedToken(client.Configuration);
 
         /// <summary>
         /// Gets the formatted token.
         /// </summary>
         /// <param name="config">The config.</param>
         /// <returns>A string.</returns>
         internal static string GetFormattedToken(DiscordConfiguration config)
         {
             return config.TokenType switch
             {
                 TokenType.Bearer => $"Bearer {config.Token}",
                 TokenType.Bot => $"Bot {config.Token}",
                 _ => throw new ArgumentException("Invalid token type specified.", nameof(config.Token)),
             };
         }
 
         /// <summary>
         /// Gets the base headers.
         /// </summary>
         /// <returns>A Dictionary.</returns>
         internal static Dictionary<string, string> GetBaseHeaders()
             => new();
 
         /// <summary>
         /// Gets the user agent.
         /// </summary>
         /// <returns>A string.</returns>
         internal static string GetUserAgent()
             => VersionHeader;
 
         /// <summary>
         /// Contains the user mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A bool.</returns>
         internal static bool ContainsUserMentions(string message)
         {
             var pattern = @"<@(\d+)>";
             var regex = new Regex(pattern, RegexOptions.ECMAScript);
             return regex.IsMatch(message);
         }
 
         /// <summary>
         /// Contains the nickname mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A bool.</returns>
         internal static bool ContainsNicknameMentions(string message)
         {
             var pattern = @"<@!(\d+)>";
             var regex = new Regex(pattern, RegexOptions.ECMAScript);
             return regex.IsMatch(message);
         }
 
         /// <summary>
         /// Contains the channel mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A bool.</returns>
         internal static bool ContainsChannelMentions(string message)
         {
             var pattern = @"<#(\d+)>";
             var regex = new Regex(pattern, RegexOptions.ECMAScript);
             return regex.IsMatch(message);
         }
 
         /// <summary>
         /// Contains the role mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A bool.</returns>
         internal static bool ContainsRoleMentions(string message)
         {
             var pattern = @"<@&(\d+)>";
             var regex = new Regex(pattern, RegexOptions.ECMAScript);
             return regex.IsMatch(message);
         }
 
         /// <summary>
         /// Contains the emojis.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A bool.</returns>
         internal static bool ContainsEmojis(string message)
         {
             var pattern = @"<a?:(.*):(\d+)>";
             var regex = new Regex(pattern, RegexOptions.ECMAScript);
             return regex.IsMatch(message);
         }
 
         /// <summary>
         /// Gets the user mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A list of ulong.</returns>
         internal static IEnumerable<ulong> GetUserMentions(DiscordMessage message)
         {
             var regex = new Regex(@"<@!?(\d+)>", RegexOptions.ECMAScript);
             var matches = regex.Matches(message.Content);
             foreach (Match match in matches)
                 yield return ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
         }
 
         /// <summary>
         /// Gets the role mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A list of ulong.</returns>
         internal static IEnumerable<ulong> GetRoleMentions(DiscordMessage message)
         {
             var regex = new Regex(@"<@&(\d+)>", RegexOptions.ECMAScript);
             var matches = regex.Matches(message.Content);
             foreach (Match match in matches)
                 yield return ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
         }
 
         /// <summary>
         /// Gets the channel mentions.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A list of ulong.</returns>
         internal static IEnumerable<ulong> GetChannelMentions(DiscordMessage message)
         {
             var regex = new Regex(@"<#(\d+)>", RegexOptions.ECMAScript);
             var matches = regex.Matches(message.Content);
             foreach (Match match in matches)
                 yield return ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
         }
 
         /// <summary>
         /// Gets the emojis.
         /// </summary>
         /// <param name="message">The message.</param>
         /// <returns>A list of ulong.</returns>
         internal static IEnumerable<ulong> GetEmojis(DiscordMessage message)
         {
             var regex = new Regex(@"<a?:([a-zA-Z0-9_]+):(\d+)>", RegexOptions.ECMAScript);
             var matches = regex.Matches(message.Content);
             foreach (Match match in matches)
                 yield return ulong.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
         }
 
         /// <summary>
         /// Are the valid slash command name.
         /// </summary>
         /// <param name="name">The name.</param>
         /// <returns>A bool.</returns>
         internal static bool IsValidSlashCommandName(string name)
         {
             var regex = new Regex(@"^[\w-]{1,32}$", RegexOptions.ECMAScript);
             return regex.IsMatch(name);
         }
 
         /// <summary>
         /// Checks the thread auto archive duration feature.
         /// </summary>
         /// <param name="guild">The guild.</param>
         /// <param name="taad">The taad.</param>
         /// <returns>A bool.</returns>
         internal static bool CheckThreadAutoArchiveDurationFeature(DiscordGuild guild, ThreadAutoArchiveDuration taad)
         {
             return taad == ThreadAutoArchiveDuration.ThreeDays
                 ? (guild.PremiumTier.HasFlag(PremiumTier.Tier_1) || guild.Features.CanSetThreadArchiveDurationThreeDays)
                 : taad != ThreadAutoArchiveDuration.OneWeek || guild.PremiumTier.HasFlag(PremiumTier.Tier_2) || guild.Features.CanSetThreadArchiveDurationSevenDays;
         }
 
         /// <summary>
         /// Checks the thread private feature.
         /// </summary>
         /// <param name="guild">The guild.</param>
         /// <returns>A bool.</returns>
         internal static bool CheckThreadPrivateFeature(DiscordGuild guild) => guild.PremiumTier.HasFlag(PremiumTier.Tier_2) || guild.Features.CanCreatePrivateThreads;
 
         /// <summary>
         /// Have the message intents.
         /// </summary>
         /// <param name="intents">The intents.</param>
         /// <returns>A bool.</returns>
         internal static bool HasMessageIntents(DiscordIntents intents)
             => intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages);
 
         /// <summary>
         /// Have the reaction intents.
         /// </summary>
         /// <param name="intents">The intents.</param>
         /// <returns>A bool.</returns>
         internal static bool HasReactionIntents(DiscordIntents intents)
             => intents.HasIntent(DiscordIntents.GuildMessageReactions) || intents.HasIntent(DiscordIntents.DirectMessageReactions);
 
         /// <summary>
         /// Have the typing intents.
         /// </summary>
         /// <param name="intents">The intents.</param>
         /// <returns>A bool.</returns>
         internal static bool HasTypingIntents(DiscordIntents intents)
             => intents.HasIntent(DiscordIntents.GuildMessageTyping) || intents.HasIntent(DiscordIntents.DirectMessageTyping);
 
         // https://discord.com/developers/docs/topics/gateway#sharding-sharding-formula
         /// <summary>
         /// Gets a shard id from a guild id and total shard count.
         /// </summary>
         /// <param name="guildId">The guild id the shard is on.</param>
         /// <param name="shardCount">The total amount of shards.</param>
         /// <returns>The shard id.</returns>
         public static int GetShardId(ulong guildId, int shardCount)
             => (int)(guildId >> 22) % shardCount;
 
         /// <summary>
         /// Helper method to create a <see cref="DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
         /// </summary>
         /// <param name="unixTime">Unix time seconds to convert.</param>
         /// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
         /// <returns>Calculated <see cref="DateTimeOffset"/>.</returns>
         public static DateTimeOffset GetDateTimeOffset(long unixTime, bool shouldThrow = true)
         {
             try
             {
                 return DateTimeOffset.FromUnixTimeSeconds(unixTime);
             }
             catch (Exception)
             {
                 if (shouldThrow)
                     throw;
 
                 return DateTimeOffset.MinValue;
             }
         }
 
         /// <summary>
         /// Helper method to create a <see cref="DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
         /// </summary>
         /// <param name="unixTime">Unix time milliseconds to convert.</param>
         /// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
         /// <returns>Calculated <see cref="DateTimeOffset"/>.</returns>
         public static DateTimeOffset GetDateTimeOffsetFromMilliseconds(long unixTime, bool shouldThrow = true)
         {
             try
             {
                 return DateTimeOffset.FromUnixTimeMilliseconds(unixTime);
             }
             catch (Exception)
             {
                 if (shouldThrow)
                     throw;
 
                 return DateTimeOffset.MinValue;
             }
         }
 
         /// <summary>
         /// Helper method to calculate Unix time seconds from a <see cref="DateTimeOffset"/> for targets that do not support this natively.
         /// </summary>
         /// <param name="dto"><see cref="DateTimeOffset"/> to calculate Unix time for.</param>
         /// <returns>Calculated Unix time.</returns>
         public static long GetUnixTime(DateTimeOffset dto)
             => dto.ToUnixTimeMilliseconds();
 
         /// <summary>
         /// Computes a timestamp from a given snowflake.
         /// </summary>
         /// <param name="snowflake">Snowflake to compute a timestamp from.</param>
         /// <returns>Computed timestamp.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static DateTimeOffset GetSnowflakeTime(this ulong snowflake)
             => DiscordClient._discordEpoch.AddMilliseconds(snowflake >> 22);
 
         /// <summary>
         /// Converts this <see cref="Permissions"/> into human-readable format.
         /// </summary>
         /// <param name="perm">Permissions enumeration to convert.</param>
         /// <returns>Human-readable permissions.</returns>
         public static string ToPermissionString(this Permissions perm)
         {
             if (perm == Permissions.None)
                 return PermissionStrings[perm];
 
             perm &= PermissionMethods.FULL_PERMS;
 
             var strs = PermissionStrings
                 .Where(xkvp => xkvp.Key != Permissions.None && (perm & xkvp.Key) == xkvp.Key)
                 .Select(xkvp => xkvp.Value);
 
             return string.Join(", ", strs.OrderBy(xs => xs));
         }
 
         /// <summary>
         /// Checks whether this string contains given characters.
         /// </summary>
         /// <param name="str">String to check.</param>
         /// <param name="characters">Characters to check for.</param>
         /// <returns>Whether the string contained these characters.</returns>
         public static bool Contains(this string str, params char[] characters)
         {
             foreach (var xc in str)
                 if (characters.Contains(xc))
                     return true;
 
             return false;
         }
 
         /// <summary>
         /// Logs the task fault.
         /// </summary>
         /// <param name="task">The task.</param>
         /// <param name="logger">The logger.</param>
         /// <param name="level">The level.</param>
         /// <param name="eventId">The event id.</param>
         /// <param name="message">The message.</param>
         internal static void LogTaskFault(this Task task, ILogger logger, LogLevel level, EventId eventId, string message)
         {
             if (task == null)
                 throw new ArgumentNullException(nameof(task));
 
             if (logger == null)
                 return;
 
             task.ContinueWith(t => logger.Log(level, eventId, t.Exception, message), TaskContinuationOptions.OnlyOnFaulted);
         }
 
         /// <summary>
         /// Deconstructs the.
         /// </summary>
         /// <param name="kvp">The kvp.</param>
         /// <param name="key">The key.</param>
         /// <param name="value">The value.</param>
         internal static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
         {
             key = kvp.Key;
             value = kvp.Value;
         }
     }
 }