diff --git a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
index 7e7c77dfb..c4675b2c1 100644
--- a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
@@ -1,148 +1,148 @@
 // 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.Globalization;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
     /// <summary>
     /// Represents a date time converter.
     /// </summary>
     public class DateTimeConverter : IArgumentConverter<DateTime>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DateTime>> IArgumentConverter<DateTime>.ConvertAsync(string value, CommandContext ctx)
         {
             return DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
                 ? Task.FromResult(new Optional<DateTime>(result))
                 : Task.FromResult(Optional.FromNoValue<DateTime>());
         }
     }
 
     /// <summary>
     /// Represents a date time offset converter.
     /// </summary>
     public class DateTimeOffsetConverter : IArgumentConverter<DateTimeOffset>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DateTimeOffset>> IArgumentConverter<DateTimeOffset>.ConvertAsync(string value, CommandContext ctx)
         {
             return DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
                 ? Task.FromResult(Optional.FromValue(result))
                 : Task.FromResult(Optional.FromNoValue<DateTimeOffset>());
         }
     }
 
     /// <summary>
     /// Represents a time span converter.
     /// </summary>
     public class TimeSpanConverter : IArgumentConverter<TimeSpan>
     {
         /// <summary>
         /// Gets or sets the time span regex.
         /// </summary>
         private static Regex TimeSpanRegex { get; set; }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="System.TimeSpanConverter"/> class.
+        /// Initializes a new instance of the <see cref="TimeSpanConverter"/> class.
         /// </summary>
         static TimeSpanConverter()
         {
 #if NETSTANDARD1_3
             TimeSpanRegex = new Regex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript);
 #else
             TimeSpanRegex = new Regex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 #endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<TimeSpan>> IArgumentConverter<TimeSpan>.ConvertAsync(string value, CommandContext ctx)
         {
             if (value == "0")
                 return Task.FromResult(Optional.FromValue(TimeSpan.Zero));
 
             if (int.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _))
                 return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
             if (!ctx.Config.CaseSensitive)
                 value = value.ToLowerInvariant();
 
             if (TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out var result))
                 return Task.FromResult(Optional.FromValue(result));
 
             var gps = new string[] { "days", "hours", "minutes", "seconds" };
             var mtc = TimeSpanRegex.Match(value);
             if (!mtc.Success)
                 return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
             var d = 0;
             var h = 0;
             var m = 0;
             var s = 0;
             foreach (var gp in gps)
             {
                 var gpc = mtc.Groups[gp].Value;
                 if (string.IsNullOrWhiteSpace(gpc))
                     continue;
 
                 var gpt = gpc[gpc.Length - 1];
                 int.TryParse(gpc.Substring(0, gpc.Length - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var val);
                 switch (gpt)
                 {
                     case 'd':
                         d = val;
                         break;
 
                     case 'h':
                         h = val;
                         break;
 
                     case 'm':
                         m = val;
                         break;
 
                     case 's':
                         s = val;
                         break;
                 }
             }
             result = new TimeSpan(d, h, m, s);
             return Task.FromResult(Optional.FromValue(result));
         }
     }
 }
diff --git a/DisCatSharp.Common/Types/SecureRandom.cs b/DisCatSharp.Common/Types/SecureRandom.cs
index 19bd691eb..e42a11075 100644
--- a/DisCatSharp.Common/Types/SecureRandom.cs
+++ b/DisCatSharp.Common/Types/SecureRandom.cs
@@ -1,348 +1,348 @@
-// This file is part of the DisCatSharp project.
+// 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.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 
 namespace DisCatSharp.Common
 {
     /// <summary>
-    /// Provides a cryptographically-secure pseudorandom number generator (CSPRNG) implementation compatible with <see cref="Random"/>.
+    /// Provides a cryptographically-secure pseudorandom number generator (CSPRNG) implementation compatible with <see cref="System.Random"/>.
     /// </summary>
     public sealed class SecureRandom : Random, IDisposable
     {
         /// <summary>
         /// Gets the r n g.
         /// </summary>
         private RandomNumberGenerator RNG { get; } = RandomNumberGenerator.Create();
 
         private volatile bool _isDisposed = false;
 
         /// <summary>
         /// Creates a new instance of <see cref="SecureRandom"/>.
         /// </summary>
         public SecureRandom()
         { }
 
         /// <summary>
         /// Finalizes this <see cref="SecureRandom"/> instance by disposing it.
         /// </summary>
         ~SecureRandom()
         {
             this.Dispose();
         }
 
         /// <summary>
         /// Fills a supplied buffer with random bytes.
         /// </summary>
         /// <param name="buffer">Buffer to fill with random bytes.</param>
         public void GetBytes(byte[] buffer)
         {
             this.RNG.GetBytes(buffer);
         }
 
         /// <summary>
         /// Fills a supplied buffer with random nonzero bytes.
         /// </summary>
         /// <param name="buffer">Buffer to fill with random nonzero bytes.</param>
         public void GetNonZeroBytes(byte[] buffer)
         {
             this.RNG.GetNonZeroBytes(buffer);
         }
         
         /// <summary>
         /// Fills a supplied memory region with random bytes.
         /// </summary>
         /// <param name="buffer">Memmory region to fill with random bytes.</param>
         public void GetBytes(Span<byte> buffer)
         {
 #if NETCOREAPP
             this.RNG.GetBytes(buffer);
 #else
             var buff = ArrayPool<byte>.Shared.Rent(buffer.Length);
             try
             {
                 var buffSpan = buff.AsSpan(0, buffer.Length);
                 this.RNG.GetBytes(buff);
                 buffSpan.CopyTo(buffer);
             }
             finally
             {
                 ArrayPool<byte>.Shared.Return(buff);
             }
 #endif
         }
         
         /// <summary>
         /// Fills a supplied memory region with random nonzero bytes.
         /// </summary>
         /// <param name="buffer">Memmory region to fill with random nonzero bytes.</param>
         public void GetNonZeroBytes(Span<byte> buffer)
         {
 #if NETCOREAPP
             this.RNG.GetNonZeroBytes(buffer);
 #else
             var buff = ArrayPool<byte>.Shared.Rent(buffer.Length);
             try
             {
                 var buffSpan = buff.AsSpan(0, buffer.Length);
                 this.RNG.GetNonZeroBytes(buff);
                 buffSpan.CopyTo(buffer);
             }
             finally
             {
                 ArrayPool<byte>.Shared.Return(buff);
             }
 #endif
         }
 
         /// <summary>
         /// Generates a signed 8-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="sbyte.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public sbyte GetInt8(sbyte min = 0, sbyte max = sbyte.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             var offset = (sbyte)(min < 0 ? -min : 0);
             min += offset;
             max += offset;
 
             return (sbyte)(Math.Abs(this.Generate<sbyte>()) % (max - min) + min - offset);
         }
 
         /// <summary>
         /// Generates a unsigned 8-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="byte.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public byte GetUInt8(byte min = 0, byte max = byte.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             return (byte)(this.Generate<byte>() % (max - min) + min);
         }
 
         /// <summary>
         /// Generates a signed 16-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="short.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public short GetInt16(short min = 0, short max = short.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             var offset = (short)(min < 0 ? -min : 0);
             min += offset;
             max += offset;
 
             return (short)(Math.Abs(this.Generate<short>()) % (max - min) + min - offset);
         }
 
         /// <summary>
         /// Generates a unsigned 16-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="ushort.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public ushort GetUInt16(ushort min = 0, ushort max = ushort.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             return (ushort)(this.Generate<ushort>() % (max - min) + min);
         }
 
         /// <summary>
         /// Generates a signed 32-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="int.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public int GetInt32(int min = 0, int max = int.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             var offset = min < 0 ? -min : 0;
             min += offset;
             max += offset;
 
             return Math.Abs(this.Generate<int>()) % (max - min) + min - offset;
         }
 
         /// <summary>
         /// Generates a unsigned 32-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="uint.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public uint GetUInt32(uint min = 0, uint max = uint.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             return this.Generate<uint>() % (max - min) + min;
         }
 
         /// <summary>
         /// Generates a signed 64-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="long.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public long GetInt64(long min = 0, long max = long.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             var offset = min < 0 ? -min : 0;
             min += offset;
             max += offset;
 
             return Math.Abs(this.Generate<long>()) % (max - min) + min - offset;
         }
 
         /// <summary>
         /// Generates a unsigned 64-bit integer within specified range.
         /// </summary>
         /// <param name="min">Minimum value to generate. Defaults to 0.</param>
         /// <param name="max">Maximum value to generate. Defaults to <see cref="ulong.MaxValue"/>.</param>
         /// <returns>Generated random value.</returns>
         public ulong GetUInt64(ulong min = 0, ulong max = ulong.MaxValue)
         {
             if (max <= min)
                 throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
             return this.Generate<ulong>() % (max - min) + min;
         }
 
         /// <summary>
         /// Generates a 32-bit floating-point number between 0.0 and 1.0.
         /// </summary>
         /// <returns>Generated 32-bit floating-point number.</returns>
         public float GetSingle()
         {
             var (i1, i2) = ((float)this.GetInt32(), (float)this.GetInt32());
             return i1 / i2 % 1.0F;
         }
 
         /// <summary>
         /// Generates a 64-bit floating-point number between 0.0 and 1.0.
         /// </summary>
         /// <returns>Generated 64-bit floating-point number.</returns>
         public double GetDouble()
         {
             var (i1, i2) = ((double)this.GetInt64(), (double)this.GetInt64());
             return i1 / i2 % 1.0;
         }
 
         /// <summary>
         /// Generates a 32-bit integer between 0 and <see cref="int.MaxValue"/>. Upper end exclusive.
         /// </summary>
         /// <returns>Generated 32-bit integer.</returns>
         public override int Next()
             => this.GetInt32();
 
         /// <summary>
         /// Generates a 32-bit integer between 0 and <paramref name="maxValue"/>. Upper end exclusive.
         /// </summary>
         /// <param name="maxValue">Maximum value of the generated integer.</param>
         /// <returns>Generated 32-bit integer.</returns>
         public override int Next(int maxValue)
             => this.GetInt32(0, maxValue);
 
         /// <summary>
         /// Generates a 32-bit integer between <paramref name="minValue"/> and <paramref name="maxValue"/>. Upper end exclusive.
         /// </summary>
         /// <param name="minValue">Minimum value of the generate integer.</param>
         /// <param name="maxValue">Maximum value of the generated integer.</param>
         /// <returns>Generated 32-bit integer.</returns>
         public override int Next(int minValue, int maxValue)
             => this.GetInt32(minValue, maxValue);
 
         /// <summary>
         /// Generates a 64-bit floating-point number between 0.0 and 1.0. Upper end exclusive.
         /// </summary>
         /// <returns>Generated 64-bit floating-point number.</returns>
         public override double NextDouble()
             => this.GetDouble();
 
         /// <summary>
         /// Fills specified buffer with random bytes.
         /// </summary>
         /// <param name="buffer">Buffer to fill with bytes.</param>
         public override void NextBytes(byte[] buffer)
             => this.GetBytes(buffer);
 
         /// <summary>
         /// Fills specified memory region with random bytes.
         /// </summary>
         /// <param name="buffer">Memory region to fill with bytes.</param>
         #if NETCOREAPP
         override 
         #endif 
         public void NextBytes(Span<byte> buffer)
             => this.GetBytes(buffer);
 
         /// <summary>
         /// Disposes this <see cref="SecureRandom"/> instance and its resources.
         /// </summary>
         public void Dispose()
         {
             if (this._isDisposed)
                 return;
 
             this._isDisposed = true;
             this.RNG.Dispose();
         }
 
         /// <summary>
         /// Generates a random 64-bit floating-point number between 0.0 and 1.0. Upper end exclusive.
         /// </summary>
         /// <returns>Generated 64-bit floating-point number.</returns>
         protected override double Sample()
             => this.GetDouble();
 
         /// <summary>
         /// Generates the.
         /// </summary>
         /// <returns>A T.</returns>
         private T Generate<T>() where T : struct
         {
             var size = Unsafe.SizeOf<T>();
             Span<byte> buff = stackalloc byte[size];
             this.GetBytes(buff);
             return MemoryMarshal.Read<T>(buff);
         }
     }
 }
diff --git a/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs b/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs
index d3331898d..b9e79deec 100644
--- a/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs
+++ b/DisCatSharp.Common/Types/Serialization/ComplexDecomposer.cs
@@ -1,116 +1,116 @@
 // 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.Linq;
 using System.Numerics;
 
 namespace DisCatSharp.Common.Serialization
 {
     /// <summary>
-    /// Decomposes <see cref="Complex"/> numbers into tuples (arrays of 2).
+    /// Decomposes <see cref="System.Numerics.Complex"/> numbers into tuples (arrays of 2).
     /// </summary>
     public sealed class ComplexDecomposer : IDecomposer
     {
         /// <summary>
         /// Gets the t complex.
         /// </summary>
         private static Type TComplex { get; } = typeof(Complex);
         /// <summary>
         /// Gets the t double array.
         /// </summary>
         private static Type TDoubleArray { get; } = typeof(double[]);
         /// <summary>
         /// Gets the t double enumerable.
         /// </summary>
         private static Type TDoubleEnumerable { get; } = typeof(IEnumerable<double>);
         /// <summary>
         /// Gets the t object array.
         /// </summary>
         private static Type TObjectArray { get; } = typeof(object[]);
         /// <summary>
         /// Gets the t object enumerable.
         /// </summary>
         private static Type TObjectEnumerable { get; } = typeof(IEnumerable<object>);
 
         /// <inheritdoc />
         public bool CanDecompose(Type t)
             => t == TComplex;
 
         /// <inheritdoc />
         public bool CanRecompose(Type t)
             => t == TDoubleArray
             || t == TObjectArray
             || TDoubleEnumerable.IsAssignableFrom(t)
             || TObjectEnumerable.IsAssignableFrom(t);
 
         /// <inheritdoc />
         public bool TryDecompose(object obj, Type tobj, out object decomposed, out Type tdecomposed)
         {
             decomposed = null;
             tdecomposed = TDoubleArray;
 
             if (tobj != TComplex || obj is not Complex c)
                 return false;
 
             decomposed = new[] { c.Real, c.Imaginary };
             return true;
         }
 
         /// <inheritdoc />
         public bool TryRecompose(object obj, Type tobj, Type trecomposed, out object recomposed)
         {
             recomposed = null;
 
             if (trecomposed != TComplex)
                 return false;
 
             // ie<double>
             if (TDoubleEnumerable.IsAssignableFrom(tobj) && obj is IEnumerable<double> ied)
             {
                 if (ied.Count() < 2)
                     return false;
 
                 var (real, imag) = ied.FirstTwoOrDefault();
                 recomposed = new Complex(real, imag);
                 return true;
             }
 
             // ie<obj>
             if (TObjectEnumerable.IsAssignableFrom(tobj) && obj is IEnumerable<object> ieo)
             {
                 if (ieo.Count() < 2)
                     return false;
 
                 var (real, imag) = ieo.FirstTwoOrDefault();
                 if (real is not double dreal || imag is not double dimag)
                     return false;
 
                 recomposed = new Complex(dreal, dimag);
                 return true;
             }
 
             return false;
         }
     }
 }
diff --git a/DisCatSharp.Docs/filter_config.yml b/DisCatSharp.Docs/filter_config.yml
index 2dc66c164..1662e478b 100644
--- a/DisCatSharp.Docs/filter_config.yml
+++ b/DisCatSharp.Docs/filter_config.yml
@@ -1,92 +1,104 @@
 apiRules:
 - exclude:
     uidRegex: ^System\.Collections\.Immutable$
 - exclude:
     uidRegex: ^System\.Runtime\.CompilerServices\.Unsafe$
 - exclude:
     uidRegex: ^System\.Runtime\.CompilerServices$
 - exclude:
     uidRegex: ^System\..*$
 - exclude:
     uidRegex: ^DisCatSharp\.Hosting\.Tests$
 - exclude:
     uidRegex: ^DisCatSharp\.Configuration\.Tests$
 attributeRules:
 - exclude:
     uidRegex: ^System\.Collections\.Immutable$
     type: Namespace
 - exclude:
     uidRegex: ^Microsoft\.Extensions\.Logging$
     type: Namespace
+- exclude:
+    uidRegex: ^Microsoft\.Extensions\.Logging\.LogLevel$
+    type: Namespace
 - exclude:
     uidRegex: ^Microsoft\.Extensions\.Hosting\.BackgroundService$
     type: Namespace
+- exclude:
+    uidRegex: ^Microsoft\.Extensions\.Hosting$
+    type: Namespace
+- exclude:
+    uidRegex: ^Microsoft\.Extensions$
+    type: Namespace
 - exclude:
     uidRegex: ^Newtonsoft\.Json$
     type: Namespace
+- exclude:
+    uidRegex: ^Newtonsoft\.Json\.JsonConverter$
+    type: Namespace
 - exclude:
     uidRegex: ^System\.Runtime\.CompilerServices\.Unsafe$
     type: Namespace
 - exclude:
     uidRegex: ^System\.Runtime\.CompilerServices$
     type: Namespace
 - exclude:
     uidRegex: ^System\.ComponentModel\.Design$
     type: Namespace
 - exclude:
     uidRegex: ^System\.ComponentModel\.Design\.Serialization$
     type: Namespace
 - exclude:
     uidRegex: ^System\.Xml\.Serialization$
     type: Namespace
 - exclude:
     uidRegex: ^System\.Web\.Compilation$
     type: Namespace
 - exclude:
     uidRegex: ^System\.Runtime\.Versioning$
     type: Namespace
 - exclude:
     uidRegex: ^System\.Runtime\.ConstrainedExecution$
     type: Namespace
 - exclude:
     uidRegex: ^System\.EnterpriseServices$
     type: Namespace
 - exclude:
     uidRegex: ^System\.Diagnostics\.CodeAnalysis$
     type: Namespace
 - include:
     uidRegex: ^System\.Diagnostics\.(ConditionalAttribute|EventLogPermissionAttribute|PerformanceCounterPermissionAttribute)$
     type: Type
 - exclude:
     uidRegex: '^System\.Diagnostics\.[^.]+$'
     type: Type
 - include:
     uidRegex: ^System\.ComponentModel\.(BindableAttribute|BrowsableAttribute|ComplexBindingPropertiesAttribute|DataObjectAttribute|DefaultBindingPropertyAttribute|ListBindableAttribute|LookupBindingPropertiesAttribute|SettingsBindableAttribute|TypeConverterAttribute)$
     type: Type
 - exclude:
     uidRegex: '^System\.ComponentModel\.[^.]+$'
     type: Type
 - exclude:
     uidRegex: ^System\.Reflection\.DefaultMemberAttribute$
     type: Type
 - exclude:
     uidRegex: ^System\.CodeDom\.Compiler\.GeneratedCodeAttribute$
     type: Type
 - exclude:
     uidRegex: '^System\.Runtime\.CompilerServices\.[^.]+$'
     type: Type
 - exclude:
     uidRegex: '^System\.Runtime\.InteropServices\.[^.]+$'
     type: Type
 - include:
     uidRegex: ^System\.Security\.(SecurityCriticalAttribute|SecurityTreatAsSafeAttribute|AllowPartiallyTrustedCallersAttribute)$
     type: Type
 - exclude:
     uidRegex: '^System\.Security\.[^.]+$'
     type: Type
 - exclude:
     uidRegex: '^System\.Web\.UI\.[^.]+$'
     type: Type
 - exclude:
     uidRegex: '^System\.Windows\.Markup\.[^.]+$'
     type: Type