diff --git a/DisCatSharp.CommandsNext/Converters/EntityConverters.cs b/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
index 679dcb754..dd7f6967c 100644
--- a/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
@@ -1,457 +1,457 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.RegularExpressions;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
 	/// <summary>
 	/// Represents a discord user converter.
 	/// </summary>
 	public class DiscordUserConverter : IArgumentConverter<DiscordUser>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordUser>> IArgumentConverter<DiscordUser>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var uid))
 			{
 				var result = await ctx.Client.GetUserAsync(uid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var m = DiscordRegEx.User.Match(value);
 			if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out uid))
 			{
 				var result = await ctx.Client.GetUserAsync(uid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var cs = ctx.Config.CaseSensitive;
 			if (!cs)
 				value = value.ToLowerInvariant();
 
 			var di = value.IndexOf('#');
 			var un = di != -1 ? value[..di] : value;
 			var dv = di != -1 ? value[(di + 1)..] : null;
 
 			var us = ctx.Client.Guilds.Values
 				.SelectMany(xkvp => xkvp.Members.Values)
 				.Where(xm => (cs ? xm.Username : xm.Username.ToLowerInvariant()) == un && ((dv != null && xm.Discriminator == dv) || dv == null));
 
 			var usr = us.FirstOrDefault();
 			return Optional.FromNullable<DiscordUser>(usr);
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord member converter.
 	/// </summary>
 	public class DiscordMemberConverter : IArgumentConverter<DiscordMember>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordMember>> IArgumentConverter<DiscordMember>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (ctx.Guild == null)
 				return Optional.None;
 
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var uid))
 			{
 				var result = await ctx.Guild.GetMemberAsync(uid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var m = DiscordRegEx.User.Match(value);
 			if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out uid))
 			{
 				var result = await ctx.Guild.GetMemberAsync(uid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var searchResult = await ctx.Guild.SearchMembersAsync(value).ConfigureAwait(false);
 			if (searchResult.Any())
 				return Optional.Some(searchResult.First());
 
 			var cs = ctx.Config.CaseSensitive;
 			if (!cs)
 				value = value.ToLowerInvariant();
 
 			var di = value.IndexOf('#');
 			var un = di != -1 ? value[..di] : value;
 			var dv = di != -1 ? value[(di + 1)..] : null;
 
 			var us = ctx.Guild.Members.Values
 				.Where(xm => ((cs ? xm.Username : xm.Username.ToLowerInvariant()) == un && ((dv != null && xm.Discriminator == dv) || dv == null))
 						  || (cs ? xm.Nickname : xm.Nickname?.ToLowerInvariant()) == value);
 
 			return Optional.FromNullable(us.FirstOrDefault());
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord channel converter.
 	/// </summary>
 	public class DiscordChannelConverter : IArgumentConverter<DiscordChannel>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordChannel>> IArgumentConverter<DiscordChannel>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var cid))
 			{
 				var result = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var m = DiscordRegEx.Channel.Match(value);
 			if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out cid))
 			{
 				var result = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var cs = ctx.Config.CaseSensitive;
 			if (!cs)
 				value = value.ToLowerInvariant();
 
 			var chn = ctx.Guild?.Channels.Values.FirstOrDefault(xc => (cs ? xc.Name : xc.Name.ToLowerInvariant()) == value);
 			return Optional.FromNullable(chn);
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord thread channel converter.
 	/// </summary>
 	public class DiscordThreadChannelConverter : IArgumentConverter<DiscordThreadChannel>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordThreadChannel>> IArgumentConverter<DiscordThreadChannel>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var tid))
 			{
 				var result = await ctx.Client.GetThreadAsync(tid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var m = DiscordRegEx.Channel.Match(value);
 			if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid))
 			{
 				var result = await ctx.Client.GetThreadAsync(tid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var cs = ctx.Config.CaseSensitive;
 			if (!cs)
 				value = value.ToLowerInvariant();
 
 			var tchn = ctx.Guild?.Threads.Values.FirstOrDefault(xc => (cs ? xc.Name : xc.Name.ToLowerInvariant()) == value);
 			return Optional.FromNullable(tchn);
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord role converter.
 	/// </summary>
 	public class DiscordRoleConverter : IArgumentConverter<DiscordRole>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		Task<Optional<DiscordRole>> IArgumentConverter<DiscordRole>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (ctx.Guild == null)
 				return Task.FromResult(Optional<DiscordRole>.None);
 
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var rid))
 			{
 				var result = ctx.Guild.GetRole(rid);
 				return Task.FromResult(Optional.FromNullable(result));
 			}
 
 			var m = DiscordRegEx.Role.Match(value);
 			if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out rid))
 			{
 				var result = ctx.Guild.GetRole(rid);
 				return Task.FromResult(Optional.FromNullable(result));
 			}
 
 			var cs = ctx.Config.CaseSensitive;
 			if (!cs)
 				value = value.ToLowerInvariant();
 
 			var rol = ctx.Guild.Roles.Values.FirstOrDefault(xr => (cs ? xr.Name : xr.Name.ToLowerInvariant()) == value);
 			return Task.FromResult(Optional.FromNullable(rol));
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord guild converter.
 	/// </summary>
 	public class DiscordGuildConverter : IArgumentConverter<DiscordGuild>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		Task<Optional<DiscordGuild>> IArgumentConverter<DiscordGuild>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var gid))
 			{
 				return ctx.Client.Guilds.TryGetValue(gid, out var result)
 					? Task.FromResult(Optional.Some(result))
 					: Task.FromResult(Optional<DiscordGuild>.None);
 			}
 
 			var cs = ctx.Config.CaseSensitive;
 			if (!cs)
 				value = value?.ToLowerInvariant();
 
 			var gld = ctx.Client.Guilds.Values.FirstOrDefault(xg => (cs ? xg.Name : xg.Name.ToLowerInvariant()) == value);
 			return Task.FromResult(Optional.FromNullable(gld));
 		}
 	}
 
 
 	/// <summary>
 	/// Represents a discord invite converter.
 	/// </summary>
 	public class DiscordInviteConverter : IArgumentConverter<DiscordInvite>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordInvite>> IArgumentConverter<DiscordInvite>.ConvertAsync(string value, CommandContext ctx)
 		{
 			var m = DiscordRegEx.Invite.Match(value);
 			if (m.Success)
 			{
-				ulong? eventId = ulong.TryParse(m.Groups["eventId"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture,
+				ulong? eventId = ulong.TryParse(m.Groups["event"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture,
 					out var eid) ? eid : null;
 				var result = await ctx.Client.GetInviteByCodeAsync(m.Groups["code"].Value, scheduledEventId: eventId).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			var inv = await ctx.Client.GetInviteByCodeAsync(value);
 			return Optional.FromNullable(inv);
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord message converter.
 	/// </summary>
 	public class DiscordMessageConverter : IArgumentConverter<DiscordMessage>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordMessage>> IArgumentConverter<DiscordMessage>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (string.IsNullOrWhiteSpace(value))
 				return Optional.None;
 
 			var msguri = value.StartsWith("<") && value.EndsWith(">") ? value[1..^1] : value;
 			ulong mid;
 			if (Uri.TryCreate(msguri, UriKind.Absolute, out var uri))
 			{
 				var uripath = DiscordRegEx.MessageLink.Match(uri.AbsoluteUri);
 				if (!uripath.Success
 					|| !ulong.TryParse(uripath.Groups["channel"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var cid)
 					|| !ulong.TryParse(uripath.Groups["message"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out mid))
 					return Optional.None;
 
 				var chn = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
 				if (chn == null)
 					return Optional.None;
 
 				var msg = await chn.GetMessageAsync(mid).ConfigureAwait(false);
 				return Optional.FromNullable(msg);
 			}
 
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out mid))
 			{
 				var result = await ctx.Channel.GetMessageAsync(mid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			return Optional.None;
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord scheduled event converter.
 	/// </summary>
 	public class DiscordScheduledEventConverter : IArgumentConverter<DiscordScheduledEvent>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		async Task<Optional<DiscordScheduledEvent>> IArgumentConverter<DiscordScheduledEvent>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (string.IsNullOrWhiteSpace(value))
 				return Optional.None;
 
 			var msguri = value.StartsWith("<") && value.EndsWith(">") ? value[1..^1] : value;
 			ulong seid;
 			if (Uri.TryCreate(msguri, UriKind.Absolute, out var uri))
 			{
 				var uripath = DiscordRegEx.Event.Match(uri.AbsoluteUri);
 				if (uripath.Success
 				    && ulong.TryParse(uripath.Groups["guild"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture,
 					    out var gid)
 				    && ulong.TryParse(uripath.Groups["event"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture,
 					    out seid))
 				{
 					var guild = await ctx.Client.GetGuildAsync(gid).ConfigureAwait(false);
 					if (guild == null)
 						return Optional.None;
 
 					var ev = await guild.GetScheduledEventAsync(seid).ConfigureAwait(false);
 					return Optional.FromNullable(ev);
 				}
 
 				try
 				{
 					var invite = await ctx.CommandsNext.ConvertArgument<DiscordInvite>(value, ctx).ConfigureAwait(false);
 					return Optional.FromNullable(invite.GuildScheduledEvent);
 				}
 				catch
 				{
 					return Optional.None;
 				}
 			}
 
 			if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out seid))
 			{
 				var result = await ctx.Guild.GetScheduledEventAsync(seid).ConfigureAwait(false);
 				return Optional.FromNullable(result);
 			}
 
 			return Optional.None;
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord emoji converter.
 	/// </summary>
 	public class DiscordEmojiConverter : IArgumentConverter<DiscordEmoji>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		Task<Optional<DiscordEmoji>> IArgumentConverter<DiscordEmoji>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (DiscordEmoji.TryFromUnicode(ctx.Client, value, out var emoji))
 			{
 				var result = emoji;
 				return Task.FromResult(Optional.Some(result));
 			}
 
 			var m = DiscordRegEx.Emoji.Match(value);
 			if (m.Success)
 			{
 				var sid = m.Groups["id"].Value;
 				var name = m.Groups["name"].Value;
 				var anim = m.Groups["animated"].Success;
 
 				return !ulong.TryParse(sid, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id)
 					? Task.FromResult(Optional<DiscordEmoji>.None)
 					: DiscordEmoji.TryFromGuildEmote(ctx.Client, id, out emoji)
 					? Task.FromResult(Optional.Some(emoji))
 					: Task.FromResult(Optional.Some(new DiscordEmoji
 					{
 						Discord = ctx.Client,
 						Id = id,
 						Name = name,
 						IsAnimated = anim,
 						RequiresColons = true,
 						IsManaged = false
 					}));
 			}
 
 			return Task.FromResult(Optional<DiscordEmoji>.None);
 		}
 	}
 
 	/// <summary>
 	/// Represents a discord color converter.
 	/// </summary>
 	public class DiscordColorConverter : IArgumentConverter<DiscordColor>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		Task<Optional<DiscordColor>> IArgumentConverter<DiscordColor>.ConvertAsync(string value, CommandContext ctx)
 		{
 			var m = CommonRegEx.HexColorString.Match(value);
 			if (m.Success && int.TryParse(m.Groups[1].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var clr))
 				return Task.FromResult(Optional.Some<DiscordColor>(clr));
 
 			m = CommonRegEx.RgbColorString.Match(value);
 			if (m.Success)
 			{
 				var p1 = byte.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var r);
 				var p2 = byte.TryParse(m.Groups[2].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var g);
 				var p3 = byte.TryParse(m.Groups[3].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var b);
 
 				return !(p1 && p2 && p3)
 					? Task.FromResult(Optional<DiscordColor>.None)
 					: Task.FromResult(Optional.Some(new DiscordColor(r, g, b)));
 			}
 
 			return Task.FromResult(Optional<DiscordColor>.None);
 		}
 	}
 }
diff --git a/DisCatSharp.Common.Tests/OptionalTests.cs b/DisCatSharp.Common.Tests/OptionalTests.cs
deleted file mode 100644
index 3d3be74d1..000000000
--- a/DisCatSharp.Common.Tests/OptionalTests.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-using System.Numerics;
-
-using DisCatSharp.Entities;
-
-using Xunit;
-
-namespace DisCatSharp.Common.Tests
-{
-	public class Tests
-	{
-		class TestClass { }
-
-		struct TestStruct { }
-
-		[Fact]
-		public void EqualityTests()
-		{
-			var c = new TestClass();
-
-			var c1 = Optional<TestClass>.None;
-			var c2 = Optional.Some(c);
-			Assert.NotEqual(c1, c2);
-
-			var c3 = Optional.Some(c);
-			Assert.Equal(c2, c3);
-
-			var c4 = Optional.Some(new TestClass());
-			Assert.NotEqual(c3, c4);
-
-			var s1 = Optional<TestStruct>.None;
-			var s2 = Optional.Some(new TestStruct());
-			Assert.NotEqual(s1, s2);
-
-			var s3 = Optional.Some(new TestStruct());
-			Assert.Equal(s2, s3);
-
-			var s4 = (Optional<TestStruct>)Optional.None;
-			Assert.Equal(s1, s4);
-		}
-
-		[Fact]
-		public void FromNullableTests()
-		{
-			var c1 = Optional.Some<TestClass>(null);
-			Assert.True(c1.HasValue);
-			Assert.Null(c1.Value);
-
-			var c2 = Optional.FromNullable<TestClass>(null);
-			Assert.False(c2.HasValue);
-
-			var c3 = Optional.FromNullable(new TestClass());
-			Assert.True(c3.HasValue);
-			Assert.NotNull(c3.Value);
-		}
-
-		[Fact]
-		public void MapTests()
-		{
-			var c1 = Optional<TestClass>.None;
-			var s1 = c1.Map(x => new TestStruct());
-			Assert.False(s1.HasValue);
-
-			c1 = Optional.Some(new TestClass());
-			s1 = c1.Map(x => new TestStruct());
-			Assert.True(s1.HasValue);
-
-			var mapped = false;
-			T Map<T>(T o)
-			{
-				mapped = true;
-				return o;
-			}
-
-			c1 = null;
-			var c2 = c1.MapOrNull(Map);
-			Assert.False(mapped);
-			Assert.True(c2.HasValue);
-			Assert.Null((TestClass)c2);
-
-			c1 = new TestClass();
-			c2 = c1.MapOrNull(Map);
-			Assert.True(mapped);
-			Assert.True(c2.HasValue);
-			Assert.Equal(c1, c2);
-			Assert.Equal(c1.Value, c2.Value);
-		}
-	}
-}
diff --git a/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs b/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
index 0475999c1..4aa3d8ddf 100644
--- a/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
+++ b/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
@@ -1,124 +1,125 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Text.RegularExpressions;
 
 namespace DisCatSharp.Common.RegularExpressions
 {
 	/// <summary>
 	/// Provides common regex for discord related things.
 	/// </summary>
 	public static class DiscordRegEx
 	{
-		private const string WEBSITE = @"(https?:\/\/)?(www\.|canary\.|ptb\.)?(discord)\.(com|net)\/";
+		// language=regex
+		private const string WEBSITE = @"(https?:\/\/)?(www\.|canary\.|ptb\.)?(discord|discordapp)\.com\/";
 
 		/// <summary>
 		/// Represents a invite.
 		/// </summary>
 		public static readonly Regex Invite
-			= new(@"^(https?:\/\/)?(www\.)?(discord\.(gg|io|me|li)|discordapp\.(com|net)\/invite)\/(.*\/)*(?<code>[a-zA-Z0-9]*)(\?event=(?<eventId>\d+))?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+			= new($@"^((https?:\/\/)?(www\.)?discord\.gg(\/.*)*|{WEBSITE}invite)\/(?<code>[a-zA-Z0-9]*)(\?event=(?<event>\d+))?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a message link.
 		/// </summary>
 		public static readonly Regex MessageLink
 			= new($@"^{WEBSITE}channels\/(?<guild>(?:\d+|@me))\/(?<channel>\d+)\/(?<message>\d+)\/?", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a emoji.
 		/// </summary>
 		public static readonly Regex Emoji
 			= new(@"^<(?<animated>a)?:(?<name>[a-zA-Z0-9_]+?):(?<id>\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a animated emoji.
 		/// </summary>
 		public static readonly Regex AnimatedEmoji
 			= new(@"^<(?<animated>a):(?<name>\w{2,32}):(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a non-animated emoji.
 		/// </summary>
 		public static readonly Regex StaticEmoji
 			= new(@"^<:(?<name>\w{2,32}):(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a timestamp.
 		/// </summary>
 		public static readonly Regex Timestamp
 			= new(@"^<t:(?<timestamp>-?\d{1,13})(:(?<style>[tTdDfFR]))?>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a default styled timestamp.
 		/// </summary>
 		public static readonly Regex DefaultStyledTimestamp
 			= new(@"^<t:(?<timestamp>-?\d{1,13})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a styled timestamp.
 		/// </summary>
 		public static readonly Regex StyledTimestamp
 			= new(@"^<t:(?<timestamp>-?\d{1,13}):(?<style>[tTdDfFR])>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a role.
 		/// </summary>
 		public static readonly Regex Role
 			= new(@"^<@&(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a channel.
 		/// </summary>
 		public static readonly Regex Channel
 			= new(@"^<#(\d+)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a user.
 		/// </summary>
 		public static readonly Regex User
 			= new(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a user with nickname.
 		/// </summary>
 		public static readonly Regex UserWithNickname
 			= new(@"^<@\!(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a user with optional nickname.
 		/// </summary>
 		public static readonly Regex UserWithOptionalNickname
 			= new(@"^<@\!?(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a user without nickname.
 		/// </summary>
 		public static readonly Regex UserWithoutNickname
 			= new(@"^<@(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
 		/// <summary>
 		/// Represents a event.
 		/// </summary>
 		public static readonly Regex Event
 			= new($@"^{WEBSITE}events\/(?<guild>\d+)\/(?<event>\d+)$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 	}
 }
diff --git a/DisCatSharp.Common.Tests/DisCatSharp.Common.Tests.csproj b/DisCatSharp.Tests/DisCatSharp.Tests.csproj
similarity index 88%
rename from DisCatSharp.Common.Tests/DisCatSharp.Common.Tests.csproj
rename to DisCatSharp.Tests/DisCatSharp.Tests.csproj
index 7b6cb909b..9b4d7d0b5 100644
--- a/DisCatSharp.Common.Tests/DisCatSharp.Common.Tests.csproj
+++ b/DisCatSharp.Tests/DisCatSharp.Tests.csproj
@@ -1,27 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
-    <Nullable>disable</Nullable>
+    <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.Combinatorial" Version="1.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.0">
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
 	  <ProjectReference Include="..\DisCatSharp\DisCatSharp.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/DisCatSharp.Tests/EntityRegexTests/EventTests.cs b/DisCatSharp.Tests/EntityRegexTests/EventTests.cs
new file mode 100644
index 000000000..7bc73ea33
--- /dev/null
+++ b/DisCatSharp.Tests/EntityRegexTests/EventTests.cs
@@ -0,0 +1,80 @@
+// This file is part of the DisCatSharp project, based off DSharpPlus.
+//
+// Copyright (c) 2021-2022 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using DisCatSharp.Common.RegularExpressions;
+
+using Xunit;
+using Xunit.Abstractions;
+
+namespace DisCatSharp.Tests.EntityRegexTests;
+
+public class EventTests
+{
+	private readonly ITestOutputHelper _output;
+	public EventTests(ITestOutputHelper output)
+	{
+		this._output = output;
+	}
+
+	[Theory, ClassData(typeof(WebsiteGenerator))]
+	void TestEventMatch(string website)
+	{
+		var evtn = $"{website}events/123/456";
+		this._output.WriteLine($"Testing \"{evtn}\".");
+		var match = DiscordRegEx.Event.Match(evtn);
+		Assert.True(match.Success);
+		Assert.Equal("123", match.Groups["guild"].Value);
+		Assert.Equal("456", match.Groups["event"].Value);
+	}
+
+	private const string VALID_EVENT = "https://discord.com/events/123/456";
+
+	[Fact]
+	void TestValidEvent() => Assert.Matches(DiscordRegEx.Event, VALID_EVENT);
+
+	[Theory, CombinatorialData]
+	void TestInvalidEvents([CombinatorialValues(
+		"",
+		"_",
+		"asd",
+		$".{VALID_EVENT}",
+		$"a{VALID_EVENT}",
+		$"{VALID_EVENT}b",
+		$"{VALID_EVENT}_",
+		"https://discord.com/events/123/",
+		"https://discord.com/events/123",
+		"iscord.com/events/123/456",
+		"https://discord.ru/events/123/456",
+		"ftp://discord.com/events/123/456",
+		"https://discord.com/stneve/123/456",
+		"https://discord.com/events/1x23/456",
+		"https://discord.com/events/123/4z56",
+		"https://discord.com/events/12_3/456",
+		"https://discord.com/events/123/45%6",
+		"https://discord.comevents/123/456",
+		"https:/discord.comevents/123/456",
+		"https:/discord.com/events/123/456",
+		"https//discord.com/events/123/456",
+		"/discord.com/events/123/456"
+	)] string evtn) =>
+		Assert.DoesNotMatch(DiscordRegEx.Event, evtn);
+}
diff --git a/DisCatSharp.Tests/EntityRegexTests/WebsiteGenerator.cs b/DisCatSharp.Tests/EntityRegexTests/WebsiteGenerator.cs
new file mode 100644
index 000000000..817464170
--- /dev/null
+++ b/DisCatSharp.Tests/EntityRegexTests/WebsiteGenerator.cs
@@ -0,0 +1,44 @@
+// This file is part of the DisCatSharp project, based off DSharpPlus.
+//
+// Copyright (c) 2021-2022 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace DisCatSharp.Tests.EntityRegexTests;
+
+class WebsiteGenerator : IEnumerable<object[]>
+{
+	private static readonly ImmutableArray<string> s_protocols = new[] { "", "http://", "https://" }.ToImmutableArray();
+	private static readonly ImmutableArray<string> s_subdomains = new[] { "", "www.", "ptb.", "canary." }.ToImmutableArray();
+	private static readonly ImmutableArray<string> s_domains = new[] { "discord", "discordapp" }.ToImmutableArray();
+
+	public IEnumerator<object[]> GetEnumerator()
+	{
+		foreach (var protocol in s_protocols)
+		foreach (var subdomain in s_subdomains)
+		foreach (var domain in s_domains)
+			yield return new object[] { $"{protocol}{subdomain}{domain}.com/" };
+	}
+
+	IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
+}
diff --git a/DisCatSharp.Tests/EventHandlerTests/BasicEventHandlerTests.cs b/DisCatSharp.Tests/EventHandlerTests/BasicEventHandlerTests.cs
new file mode 100644
index 000000000..0550c5657
--- /dev/null
+++ b/DisCatSharp.Tests/EventHandlerTests/BasicEventHandlerTests.cs
@@ -0,0 +1,142 @@
+// This file is part of the DisCatSharp project, based off DSharpPlus.
+//
+// Copyright (c) 2021-2022 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+
+using DisCatSharp.EventArgs;
+
+using Xunit;
+
+namespace DisCatSharp.Tests.EventHandlerTests;
+
+public class BasicEventHandlerTests
+{
+	[EventHandler]
+	private class HandlerA { }
+
+	[EventHandler]
+	private class HandlerB
+	{
+		[Event]
+		public Task MessageCreated(DiscordClient sender, MessageCreateEventArgs args) => Task.CompletedTask;
+
+		[Event(DiscordEvent.MessageDeleted)]
+		private static Task SomeEvent(DiscordClient sender, MessageDeleteEventArgs args) => Task.CompletedTask;
+	}
+
+	[EventHandler]
+	private static class HandlerC
+	{
+		[Event]
+		public static Task MessageCreated(DiscordClient sender, MessageCreateEventArgs args) => Task.CompletedTask;
+	}
+
+	public abstract class HandlerD
+	{
+		[Event]
+		public Task ChannelCreated(DiscordClient sender, ChannelCreateEventArgs args) => Task.CompletedTask;
+
+		[Event]
+		public static Task ChannelDeleted(DiscordClient sender, ChannelDeleteEventArgs args) => Task.CompletedTask;
+	}
+
+	private class BadHandlerA
+	{
+		[Event]
+		public int MessageCreated(object? obj, dynamic dynamic) => 1;
+	}
+		
+	private abstract class BadHandlerB
+	{
+		[Event]
+		private static Task ThisEventDoesNotExist() => Task.CompletedTask;
+	}
+
+	private readonly DiscordClient _client = new(new() { Token = "1" });
+
+	[Fact]
+	public void TestUtility()
+	{
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		this._client.MessageCreated += (_, _) => Task.CompletedTask;
+		Assert.True(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		Assert.Throws<ArgumentException>(() => this.IsEventRegistered(""));
+		Assert.Throws<ArgumentException>(() => this.IsEventRegistered("ThisEventDoesNotExist"));
+	}
+
+	[Fact]
+	public void TestUnregistrationWithoutRegistration()
+	{
+		this._client.UnregisterEventHandler<HandlerB>();
+		this._client.UnregisterEventHandlers(Assembly.GetExecutingAssembly());
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageDeleted)));
+	}
+
+	[Fact]
+	public void TestSimpleRegistration()
+	{
+		this._client.RegisterEventHandler<HandlerB>();
+		Assert.True(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		Assert.True(this.IsEventRegistered(nameof(this._client.MessageDeleted)));
+		this._client.UnregisterEventHandler<HandlerB>();
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageDeleted)));
+
+		this._client.RegisterEventHandler<HandlerD>();
+		Assert.False(this.IsEventRegistered(nameof(this._client.ChannelCreated)));
+		Assert.True(this.IsEventRegistered(nameof(this._client.ChannelDeleted)));
+		this._client.UnregisterEventHandler<HandlerD>();
+		Assert.False(this.IsEventRegistered(nameof(this._client.ChannelDeleted)));
+	}
+
+	[Fact]
+	public void TestAssemblyRegistration()
+	{
+		this._client.RegisterEventHandlers(Assembly.GetExecutingAssembly());
+		Assert.True(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		Assert.True(this.IsEventRegistered(nameof(this._client.MessageDeleted)));
+		this._client.UnregisterEventHandlers(Assembly.GetExecutingAssembly());
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageCreated)));
+		Assert.False(this.IsEventRegistered(nameof(this._client.MessageDeleted)));
+	}
+
+	[Fact]
+	public void TestInvalidHandlers()
+	{
+		Assert.Throws<ArgumentException>(() => this._client.RegisterEventHandler<BadHandlerA>());
+		Assert.Throws<ArgumentException>(() => this._client.RegisterEventHandler<BadHandlerB>());
+	}
+
+	private bool IsEventRegistered(string name) {
+		// This is super hacky, but I think it should be good enough.
+		if (name.Length == 0) { throw new ArgumentException("name mustn't be empty"); }
+		name = "_" + char.ToLower(name[0]) + name.Substring(1);
+		var asyncEvent = typeof(DiscordClient).GetField(name, BindingFlags.NonPublic | BindingFlags.Instance)?.GetValue(this._client);
+		dynamic handlers = asyncEvent?.GetType().GetField("_handlers", BindingFlags.NonPublic | BindingFlags.Instance)?.GetValue(asyncEvent)
+		                   ?? throw new ArgumentException($"Unknown event \"{name}\"");
+		return handlers.Length != 0;
+	}
+
+}
diff --git a/DisCatSharp.Tests/EventHandlerTests/EventsEnumIntegrityTests.cs b/DisCatSharp.Tests/EventHandlerTests/EventsEnumIntegrityTests.cs
new file mode 100644
index 000000000..ca4ef9101
--- /dev/null
+++ b/DisCatSharp.Tests/EventHandlerTests/EventsEnumIntegrityTests.cs
@@ -0,0 +1,49 @@
+// This file is part of the DisCatSharp project, based off DSharpPlus.
+//
+// Copyright (c) 2021-2022 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System.Linq;
+
+using Xunit;
+
+namespace DisCatSharp.Tests.EventHandlerTests;
+
+public class EventsEnumIntegrityTests
+{
+	[Fact]
+	void TestEnumToEvent()
+	{
+		foreach (var value in typeof(DiscordEvent).GetEnumValues())
+		{
+			Assert.NotNull(typeof(DiscordClient).GetEvent(value.ToString()!));
+		}
+	}
+
+	[Fact]
+	void TestEventToEnum()
+	{
+		var enumNames = typeof(DiscordEvent).GetEnumNames().ToHashSet();
+		foreach (var evtn in typeof(DiscordClient).GetEvents())
+		{
+			Assert.Contains(evtn.Name, enumNames);
+		}
+	}
+}
diff --git a/DisCatSharp.Tests/EventHandlerTests/ServiceProviderTests.cs b/DisCatSharp.Tests/EventHandlerTests/ServiceProviderTests.cs
new file mode 100644
index 000000000..4f1ecc47b
--- /dev/null
+++ b/DisCatSharp.Tests/EventHandlerTests/ServiceProviderTests.cs
@@ -0,0 +1,53 @@
+// This file is part of the DisCatSharp project, based off DSharpPlus.
+//
+// Copyright (c) 2021-2022 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using Xunit;
+
+namespace DisCatSharp.Tests.EventHandlerTests;
+
+public class ServiceProviderTests
+{
+	private class Resource { }
+
+	private class Handler
+	{
+		public Handler(Resource res) { }
+	}
+
+	[Fact]
+	public void Test()
+	{
+		var poorClient = new DiscordClient(new() { Token = "1" });
+		Assert.ThrowsAny<Exception>(() => poorClient.RegisterEventHandler<Handler>());
+
+		var richClient = new DiscordClient(new()
+		{
+			Token = "2",
+			ServiceProvider = new ServiceCollection().AddSingleton<Resource>().BuildServiceProvider(),
+		});
+		richClient.RegisterEventHandler<Handler>(); // May not throw.
+	}
+}
diff --git a/DisCatSharp.Tests/OptionalTests.cs b/DisCatSharp.Tests/OptionalTests.cs
new file mode 100644
index 000000000..f50ddcf72
--- /dev/null
+++ b/DisCatSharp.Tests/OptionalTests.cs
@@ -0,0 +1,107 @@
+// This file is part of the DisCatSharp project, based off DSharpPlus.
+//
+// Copyright (c) 2021-2022 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using DisCatSharp.Entities;
+
+using Xunit;
+
+namespace DisCatSharp.Tests;
+
+public class OptionalTests
+{
+	class TestClass { }
+
+	struct TestStruct { }
+
+	[Fact]
+	public void EqualityTests()
+	{
+		var c = new TestClass();
+
+		var c1 = Optional<TestClass>.None;
+		var c2 = Optional.Some(c);
+		Assert.NotEqual(c1, c2);
+
+		var c3 = Optional.Some(c);
+		Assert.Equal(c2, c3);
+
+		var c4 = Optional.Some(new TestClass());
+		Assert.NotEqual(c3, c4);
+
+		var s1 = Optional<TestStruct>.None;
+		var s2 = Optional.Some(new TestStruct());
+		Assert.NotEqual(s1, s2);
+
+		var s3 = Optional.Some(new TestStruct());
+		Assert.Equal(s2, s3);
+
+		var s4 = (Optional<TestStruct>)Optional.None;
+		Assert.Equal(s1, s4);
+	}
+
+	[Fact]
+	public void FromNullableTests()
+	{
+		var c1 = Optional.Some<TestClass>(null);
+		Assert.True(c1.HasValue);
+		Assert.Null(c1.Value);
+
+		var c2 = Optional.FromNullable<TestClass>(null);
+		Assert.False(c2.HasValue);
+
+		var c3 = Optional.FromNullable(new TestClass());
+		Assert.True(c3.HasValue);
+		Assert.NotNull(c3.Value);
+	}
+
+	[Fact]
+	public void MapTests()
+	{
+		var c1 = Optional<TestClass>.None;
+		var s1 = c1.Map(x => new TestStruct());
+		Assert.False(s1.HasValue);
+
+		c1 = Optional.Some(new TestClass());
+		s1 = c1.Map(x => new TestStruct());
+		Assert.True(s1.HasValue);
+
+		var mapped = false;
+		T Map<T>(T o)
+		{
+			mapped = true;
+			return o;
+		}
+
+		c1 = null;
+		var c2 = c1.MapOrNull(Map);
+		Assert.False(mapped);
+		Assert.True(c2.HasValue);
+		Assert.Null((TestClass)c2);
+
+		c1 = new TestClass();
+		c2 = c1.MapOrNull(Map);
+		Assert.True(mapped);
+		Assert.True(c2.HasValue);
+		Assert.Equal(c1, c2);
+		Assert.Equal(c1.Value, c2.Value);
+	}
+}
diff --git a/DisCatSharp.sln b/DisCatSharp.sln
index 72c0d3edc..683357d42 100644
--- a/DisCatSharp.sln
+++ b/DisCatSharp.sln
@@ -1,168 +1,161 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.1.31911.260
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp", "DisCatSharp\DisCatSharp.csproj", "{EB3D8310-DFAD-4295-97F9-82E253647583}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.VoiceNext", "DisCatSharp.VoiceNext\DisCatSharp.VoiceNext.csproj", "{FB6B9EE9-65FB-4DFB-8D51-06F0BE6C1BA5}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{4255B64D-92EC-46B3-BC3B-ED2C3A8073EE}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		.gitattributes = .gitattributes
 		.gitignore = .gitignore
 		BUILDING.md = BUILDING.md
 		CODE_OF_CONDUCT.md = CODE_OF_CONDUCT.md
 		CONTRIBUTING.md = CONTRIBUTING.md
 		LICENSE.md = LICENSE.md
 		README.md = README.md
 		SECURITY.md = SECURITY.md
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.CommandsNext", "DisCatSharp.CommandsNext\DisCatSharp.CommandsNext.csproj", "{C8ED55FB-E028-468D-955F-1534C20274EF}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Interactivity", "DisCatSharp.Interactivity\DisCatSharp.Interactivity.csproj", "{DD32BEC3-0189-479F-86DC-CCF95E5634A9}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{F953F5D0-F0C9-41E6-ADBF-60A76D295899}"
 	ProjectSection(SolutionItems) = preProject
 		.nuget\NuGet.config = .nuget\NuGet.config
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Build Items", "Build Items", "{84464D70-687B-40A8-836D-C4F737698969}"
 	ProjectSection(SolutionItems) = preProject
 		appveyor.yml = appveyor.yml
 		.github\workflows\codeql-analysis.yml = .github\workflows\codeql-analysis.yml
 		.github\dependabot.yml = .github\dependabot.yml
 		DisCatSharp.targets = DisCatSharp.targets
 		docs-oneclick-rebuild.ps1 = docs-oneclick-rebuild.ps1
 		.github\workflows\docs.yml = .github\workflows\docs.yml
 		.github\workflows\dotnet.yml = .github\workflows\dotnet.yml
 		Library.targets = Library.targets
 		NuGet.targets = NuGet.targets
 		oneclick-rebuild.ps1 = oneclick-rebuild.ps1
 		Package.targets = Package.targets
 		rebuild-all.ps1 = rebuild-all.ps1
 		rebuild-docs.ps1 = rebuild-docs.ps1
 		rebuild-lib.ps1 = rebuild-lib.ps1
 		Version.targets = Version.targets
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{430C28D8-5F85-4D6E-AA68-211549435245}"
 	ProjectSection(SolutionItems) = preProject
 		.github\ISSUE_TEMPLATE\bug_report.md = .github\ISSUE_TEMPLATE\bug_report.md
 		.github\CODEOWNERS = .github\CODEOWNERS
 		.github\workflows\codeql-analysis.yml = .github\workflows\codeql-analysis.yml
 		.github\workflows\docs-preview.yml = .github\workflows\docs-preview.yml
 		.github\workflows\docs.yml = .github\workflows\docs.yml
 		.github\workflows\dotnet.yml = .github\workflows\dotnet.yml
 		.github\ISSUE_TEMPLATE\feature_request.md = .github\ISSUE_TEMPLATE\feature_request.md
 		.github\FUNDING.yml = .github\FUNDING.yml
 		.github\pull_request_template.md = .github\pull_request_template.md
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Lavalink", "DisCatSharp.Lavalink\DisCatSharp.Lavalink.csproj", "{A8B8FB09-C6AF-4F28-89B8-B53EE0DCE6E5}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.VoiceNext.Natives", "DisCatSharp.VoiceNext.Natives\DisCatSharp.VoiceNext.Natives.csproj", "{BEC47B41-71E4-41D1-A4F9-BB7C56A1B82B}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Common", "DisCatSharp.Common\DisCatSharp.Common.csproj", "{CD84A5C7-C7FF-48CA-B23D-FA726CF80E09}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.ApplicationCommands", "DisCatSharp.ApplicationCommands\DisCatSharp.ApplicationCommands.csproj", "{AD530FD0-523C-4DE7-9AF6-B9A3785492C2}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Configuration", "DisCatSharp.Configuration\DisCatSharp.Configuration.csproj", "{603287D3-1EF2-47F1-A611-C7F25869DE14}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Configuration.Tests", "DisCatSharp.Configuration.Tests\DisCatSharp.Configuration.Tests.csproj", "{E15E88B4-63AD-42DE-B685-D31697C62194}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Hosting", "DisCatSharp.Hosting\DisCatSharp.Hosting.csproj", "{72CCE5D5-926B-432A-876A-065FA2BC9B7B}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Hosting.Tests", "DisCatSharp.Hosting.Tests\DisCatSharp.Hosting.Tests.csproj", "{D02B598A-F0C9-4A8C-B8DE-7C0BAC8C9B94}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Hosting.DependencyInjection", "DisCatSharp.Hosting.DependencyInjection\DisCatSharp.Hosting.DependencyInjection.csproj", "{2D67D1DD-E5B2-40C7-80E2-54D63730E7F0}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{B15E40E0-03FD-4852-B19B-2C50BCC67704}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.EventHandlers.Tests", "DisCatSharp.EventHandlers.Tests\DisCatSharp.EventHandlers.Tests.csproj", "{FC588E5D-E0DD-48E6-8C90-F30158E2ED06}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DisCatSharp.Common.Tests", "DisCatSharp.Common.Tests\DisCatSharp.Common.Tests.csproj", "{C8EDD958-4641-4718-9E6D-125614314C10}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DisCatSharp.Tests", "DisCatSharp.Tests\DisCatSharp.Tests.csproj", "{1407FAE8-DAC1-4E89-AA15-4E4592CCC8A0}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{EB3D8310-DFAD-4295-97F9-82E253647583}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{EB3D8310-DFAD-4295-97F9-82E253647583}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{EB3D8310-DFAD-4295-97F9-82E253647583}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{EB3D8310-DFAD-4295-97F9-82E253647583}.Release|Any CPU.Build.0 = Release|Any CPU
 		{FB6B9EE9-65FB-4DFB-8D51-06F0BE6C1BA5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{FB6B9EE9-65FB-4DFB-8D51-06F0BE6C1BA5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FB6B9EE9-65FB-4DFB-8D51-06F0BE6C1BA5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FB6B9EE9-65FB-4DFB-8D51-06F0BE6C1BA5}.Release|Any CPU.Build.0 = Release|Any CPU
 		{C8ED55FB-E028-468D-955F-1534C20274EF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{C8ED55FB-E028-468D-955F-1534C20274EF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C8ED55FB-E028-468D-955F-1534C20274EF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C8ED55FB-E028-468D-955F-1534C20274EF}.Release|Any CPU.Build.0 = Release|Any CPU
 		{DD32BEC3-0189-479F-86DC-CCF95E5634A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{DD32BEC3-0189-479F-86DC-CCF95E5634A9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DD32BEC3-0189-479F-86DC-CCF95E5634A9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DD32BEC3-0189-479F-86DC-CCF95E5634A9}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A8B8FB09-C6AF-4F28-89B8-B53EE0DCE6E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A8B8FB09-C6AF-4F28-89B8-B53EE0DCE6E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A8B8FB09-C6AF-4F28-89B8-B53EE0DCE6E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A8B8FB09-C6AF-4F28-89B8-B53EE0DCE6E5}.Release|Any CPU.Build.0 = Release|Any CPU
 		{BEC47B41-71E4-41D1-A4F9-BB7C56A1B82B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{BEC47B41-71E4-41D1-A4F9-BB7C56A1B82B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{BEC47B41-71E4-41D1-A4F9-BB7C56A1B82B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{BEC47B41-71E4-41D1-A4F9-BB7C56A1B82B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{CD84A5C7-C7FF-48CA-B23D-FA726CF80E09}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{CD84A5C7-C7FF-48CA-B23D-FA726CF80E09}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{CD84A5C7-C7FF-48CA-B23D-FA726CF80E09}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{CD84A5C7-C7FF-48CA-B23D-FA726CF80E09}.Release|Any CPU.Build.0 = Release|Any CPU
 		{AD530FD0-523C-4DE7-9AF6-B9A3785492C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{AD530FD0-523C-4DE7-9AF6-B9A3785492C2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{AD530FD0-523C-4DE7-9AF6-B9A3785492C2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{AD530FD0-523C-4DE7-9AF6-B9A3785492C2}.Release|Any CPU.Build.0 = Release|Any CPU
 		{603287D3-1EF2-47F1-A611-C7F25869DE14}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{603287D3-1EF2-47F1-A611-C7F25869DE14}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{603287D3-1EF2-47F1-A611-C7F25869DE14}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{603287D3-1EF2-47F1-A611-C7F25869DE14}.Release|Any CPU.Build.0 = Release|Any CPU
 		{E15E88B4-63AD-42DE-B685-D31697C62194}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{E15E88B4-63AD-42DE-B685-D31697C62194}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E15E88B4-63AD-42DE-B685-D31697C62194}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E15E88B4-63AD-42DE-B685-D31697C62194}.Release|Any CPU.Build.0 = Release|Any CPU
 		{72CCE5D5-926B-432A-876A-065FA2BC9B7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{72CCE5D5-926B-432A-876A-065FA2BC9B7B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{72CCE5D5-926B-432A-876A-065FA2BC9B7B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{72CCE5D5-926B-432A-876A-065FA2BC9B7B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{D02B598A-F0C9-4A8C-B8DE-7C0BAC8C9B94}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{D02B598A-F0C9-4A8C-B8DE-7C0BAC8C9B94}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D02B598A-F0C9-4A8C-B8DE-7C0BAC8C9B94}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D02B598A-F0C9-4A8C-B8DE-7C0BAC8C9B94}.Release|Any CPU.Build.0 = Release|Any CPU
 		{2D67D1DD-E5B2-40C7-80E2-54D63730E7F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{2D67D1DD-E5B2-40C7-80E2-54D63730E7F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2D67D1DD-E5B2-40C7-80E2-54D63730E7F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2D67D1DD-E5B2-40C7-80E2-54D63730E7F0}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FC588E5D-E0DD-48E6-8C90-F30158E2ED06}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FC588E5D-E0DD-48E6-8C90-F30158E2ED06}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FC588E5D-E0DD-48E6-8C90-F30158E2ED06}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FC588E5D-E0DD-48E6-8C90-F30158E2ED06}.Release|Any CPU.Build.0 = Release|Any CPU
-		{C8EDD958-4641-4718-9E6D-125614314C10}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C8EDD958-4641-4718-9E6D-125614314C10}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C8EDD958-4641-4718-9E6D-125614314C10}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C8EDD958-4641-4718-9E6D-125614314C10}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1407FAE8-DAC1-4E89-AA15-4E4592CCC8A0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1407FAE8-DAC1-4E89-AA15-4E4592CCC8A0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1407FAE8-DAC1-4E89-AA15-4E4592CCC8A0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1407FAE8-DAC1-4E89-AA15-4E4592CCC8A0}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{430C28D8-5F85-4D6E-AA68-211549435245} = {4255B64D-92EC-46B3-BC3B-ED2C3A8073EE}
 		{E15E88B4-63AD-42DE-B685-D31697C62194} = {B15E40E0-03FD-4852-B19B-2C50BCC67704}
 		{D02B598A-F0C9-4A8C-B8DE-7C0BAC8C9B94} = {B15E40E0-03FD-4852-B19B-2C50BCC67704}
-		{FC588E5D-E0DD-48E6-8C90-F30158E2ED06} = {B15E40E0-03FD-4852-B19B-2C50BCC67704}
-		{C8EDD958-4641-4718-9E6D-125614314C10} = {B15E40E0-03FD-4852-B19B-2C50BCC67704}
+		{1407FAE8-DAC1-4E89-AA15-4E4592CCC8A0} = {B15E40E0-03FD-4852-B19B-2C50BCC67704}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {23F3A981-51B8-4285-A38C-3267F1D25FE7}
 	EndGlobalSection
 EndGlobal