From 9b6f76d456729f102a4e934f1a95892b12d989bd Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Mon, 29 Sep 2025 22:57:25 +0100
Subject: [PATCH 1/2] add AOT mode checks to prevent unsupported reflection
 usage and suppress AOT warnings in reflection classes

---
 .../Strategies/ReflectionPropertyStrategy.cs  |   10 +-
 .../Building/ReflectionMetadataBuilder.cs     |    8 +
 .../Building/TestDataCollectorFactory.cs      |    4 -
 .../Discovery/ReflectionAttributeExtractor.cs |   27 +-
 .../ReflectionGenericTypeResolver.cs          |   28 +-
 .../ReflectionHookDiscoveryService.cs         |   45 +-
 .../Discovery/ReflectionTestDataCollector.cs  |   69 +-
 ...ary_Has_No_API_Changes.Net4_7.verified.txt | 3810 +++++++++++------
 8 files changed, 2619 insertions(+), 1382 deletions(-)

diff --git a/TUnit.Core/PropertyInjection/Initialization/Strategies/ReflectionPropertyStrategy.cs b/TUnit.Core/PropertyInjection/Initialization/Strategies/ReflectionPropertyStrategy.cs
index f5028337d2..581bb2a816 100644
--- a/TUnit.Core/PropertyInjection/Initialization/Strategies/ReflectionPropertyStrategy.cs
+++ b/TUnit.Core/PropertyInjection/Initialization/Strategies/ReflectionPropertyStrategy.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using TUnit.Core.DataSources;
 using TUnit.Core.Initialization;
@@ -33,6 +34,13 @@ public bool CanHandle(PropertyInitializationContext context)
     [UnconditionalSuppressMessage("Trimming", "IL2072", Justification = "Reflection mode support")]
     public async Task InitializePropertyAsync(PropertyInitializationContext context)
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         if (context.PropertyInfo == null || context.DataSource == null)
         {
             return;
@@ -58,4 +66,4 @@ public async Task InitializePropertyAsync(PropertyInitializationContext context)
         PropertyTrackingService.AddToTestContext(context, resolvedValue);
     }
 
-}
\ No newline at end of file
+}
diff --git a/TUnit.Engine/Building/ReflectionMetadataBuilder.cs b/TUnit.Engine/Building/ReflectionMetadataBuilder.cs
index e33dd190c2..f107b5e958 100644
--- a/TUnit.Engine/Building/ReflectionMetadataBuilder.cs
+++ b/TUnit.Engine/Building/ReflectionMetadataBuilder.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using TUnit.Core;
 
 namespace TUnit.Engine.Building;
@@ -20,6 +21,13 @@ public static MethodMetadata CreateMethodMetadata(
             | DynamicallyAccessedMemberTypes.PublicProperties)] Type type,
         System.Reflection.MethodInfo method)
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         return new MethodMetadata
         {
             Name = method.Name,
diff --git a/TUnit.Engine/Building/TestDataCollectorFactory.cs b/TUnit.Engine/Building/TestDataCollectorFactory.cs
index e027accaf7..8ae93a709d 100644
--- a/TUnit.Engine/Building/TestDataCollectorFactory.cs
+++ b/TUnit.Engine/Building/TestDataCollectorFactory.cs
@@ -23,8 +23,6 @@ internal static class TestDataCollectorFactory
     /// Creates a test data collector based on the specified or detected mode.
     /// Source generation mode is preferred for AOT compatibility.
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming", "IL2026:Using member 'TUnit.Engine.Discovery.ReflectionTestDataCollector.ReflectionTestDataCollector()' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code", Justification = "Reflection mode is explicitly chosen and cannot support trimming")]
-    [UnconditionalSuppressMessage("AOT", "IL3050:Using member 'TUnit.Engine.Discovery.ReflectionTestDataCollector.ReflectionTestDataCollector()' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling", Justification = "Reflection mode is explicitly chosen and cannot support AOT")]
     public static ITestDataCollector Create(bool? useSourceGeneration = null, Assembly[]? assembliesToScan = null)
     {
         var isSourceGenerationEnabled = useSourceGeneration ?? SourceRegistrar.IsEnabled;
@@ -43,8 +41,6 @@ public static ITestDataCollector Create(bool? useSourceGeneration = null, Assemb
     /// Attempts AOT mode first, falls back to reflection if no source-generated tests found.
     /// This provides automatic mode selection for optimal performance and compatibility.
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming", "IL2026:Using member 'TUnit.Engine.Discovery.ReflectionTestDataCollector.ReflectionTestDataCollector()' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code", Justification = "Reflection mode is a fallback and cannot support trimming")]
-    [UnconditionalSuppressMessage("AOT", "IL3050:Using member 'TUnit.Engine.Discovery.ReflectionTestDataCollector.ReflectionTestDataCollector()' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling", Justification = "Reflection mode is a fallback and cannot support AOT")]
     public static async Task<ITestDataCollector> CreateAutoDetectAsync(string testSessionId, Assembly[]? assembliesToScan = null)
     {
         // Try AOT mode first (check if any tests were registered)
diff --git a/TUnit.Engine/Discovery/ReflectionAttributeExtractor.cs b/TUnit.Engine/Discovery/ReflectionAttributeExtractor.cs
index 4c6e29d16b..01b78e1d4e 100644
--- a/TUnit.Engine/Discovery/ReflectionAttributeExtractor.cs
+++ b/TUnit.Engine/Discovery/ReflectionAttributeExtractor.cs
@@ -1,6 +1,7 @@
 using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using TUnit.Core;
 
 namespace TUnit.Engine.Discovery;
@@ -59,8 +60,15 @@ public override int GetHashCode()
     /// </summary>
     public static T? GetAttribute<T>(Type testClass, MethodInfo? testMethod = null) where T : Attribute
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         var cacheKey = new AttributeCacheKey(testClass, testMethod, typeof(T));
-        
+
         return (T?)_attributeCache.GetOrAdd(cacheKey, key =>
         {
             // Original lookup logic preserved
@@ -88,6 +96,13 @@ public override int GetHashCode()
     /// </summary>
     public static IEnumerable<T> GetAttributes<T>(Type testClass, MethodInfo? testMethod = null) where T : Attribute
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         var attributes = new List<T>();
 
         attributes.AddRange(testClass.Assembly.GetCustomAttributes<T>());
@@ -104,7 +119,7 @@ public static IEnumerable<T> GetAttributes<T>(Type testClass, MethodInfo? testMe
     public static string[] ExtractCategories(Type testClass, MethodInfo testMethod)
     {
         var categories = new HashSet<string>();
-        
+
         foreach (var attr in GetAttributes<CategoryAttribute>(testClass, testMethod))
         {
             categories.Add(attr.Category);
@@ -128,7 +143,7 @@ public static bool CanRunInParallel(Type testClass, MethodInfo testMethod)
     public static TestDependency[] ExtractDependencies(Type testClass, MethodInfo testMethod)
     {
         var dependencies = new List<TestDependency>();
-        
+
         foreach (var attr in GetAttributes<DependsOnAttribute>(testClass, testMethod))
         {
             dependencies.Add(attr.ToTestDependency());
@@ -155,13 +170,13 @@ public static IDataSourceAttribute[] ExtractDataSources(ICustomAttributeProvider
     public static Attribute[] GetAllAttributes(Type testClass, MethodInfo testMethod)
     {
         var attributes = new List<Attribute>();
-        
+
         // Add in reverse order of precedence so method attributes come first
         // This ensures ScopedAttributeFilter will keep method-level attributes over class/assembly
         attributes.AddRange(testMethod.GetCustomAttributes());
         attributes.AddRange(testClass.GetCustomAttributes());
         attributes.AddRange(testClass.Assembly.GetCustomAttributes());
-        
+
         return attributes.ToArray();
     }
 
@@ -193,4 +208,4 @@ public static PropertyDataSource[] ExtractPropertyDataSources([DynamicallyAccess
 
         return propertyDataSources.ToArray();
     }
-}
\ No newline at end of file
+}
diff --git a/TUnit.Engine/Discovery/ReflectionGenericTypeResolver.cs b/TUnit.Engine/Discovery/ReflectionGenericTypeResolver.cs
index 2c485f2ee2..8b6974cd92 100644
--- a/TUnit.Engine/Discovery/ReflectionGenericTypeResolver.cs
+++ b/TUnit.Engine/Discovery/ReflectionGenericTypeResolver.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using TUnit.Core;
 
 namespace TUnit.Engine.Discovery;
@@ -7,7 +8,13 @@ namespace TUnit.Engine.Discovery;
 /// <summary>
 /// Handles generic type resolution and instantiation for reflection-based test discovery
 /// </summary>
-[RequiresUnreferencedCode("Reflection-based generic type resolution requires unreferenced code")]
+[UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "Reflection mode cannot support trimming")]
+[UnconditionalSuppressMessage("Trimming", "IL2055:Call to 'System.Type.MakeGenericType' can not be statically analyzed", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2065:Value passed to implicit 'this' parameter of method can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2067:Target parameter does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2070:Target method does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicMethods' in call to 'System.Type.GetMethods(BindingFlags)'", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "Reflection mode cannot support AOT")]
 internal static class ReflectionGenericTypeResolver
 {
     /// <summary>
@@ -15,6 +22,13 @@ internal static class ReflectionGenericTypeResolver
     /// </summary>
     public static Type[]? DetermineGenericTypeArguments(Type genericTypeDefinition, object?[] dataRow)
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         var genericParameters = genericTypeDefinition.GetGenericArguments();
 
         // If no data row or empty data, can't determine types
@@ -68,9 +82,6 @@ internal static class ReflectionGenericTypeResolver
     /// <summary>
     /// Extracts generic type information including constraints
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2065:Value passed to implicit 'this' parameter of method 'System.Type.GetInterfaces()' can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements",
-        Justification = "Reflection mode requires dynamic access")]
     public static GenericTypeInfo? ExtractGenericTypeInfo(Type testClass)
     {
         if (!testClass.IsGenericTypeDefinition)
@@ -106,9 +117,6 @@ internal static class ReflectionGenericTypeResolver
     /// <summary>
     /// Extracts generic method information including parameter positions
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2065:Value passed to implicit 'this' parameter of method 'System.Type.GetInterfaces()' can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements",
-        Justification = "Reflection mode requires dynamic access")]
     public static GenericMethodInfo? ExtractGenericMethodInfo(MethodInfo method)
     {
         if (!method.IsGenericMethodDefinition)
@@ -157,10 +165,6 @@ internal static class ReflectionGenericTypeResolver
     /// <summary>
     /// Creates a concrete type from a generic type definition and validates the type arguments
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming", "IL2055:Call to 'System.Type.MakeGenericType' can not be statically analyzed",
-        Justification = "Reflection mode requires dynamic access")]
-    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.",
-        Justification = "Reflection mode cannot support AOT")]
     public static Type CreateConcreteType(Type genericTypeDefinition, Type[] typeArguments)
     {
         var genericParams = genericTypeDefinition.GetGenericArguments();
@@ -174,4 +178,4 @@ public static Type CreateConcreteType(Type genericTypeDefinition, Type[] typeArg
 
         return genericTypeDefinition.MakeGenericType(typeArguments);
     }
-}
\ No newline at end of file
+}
diff --git a/TUnit.Engine/Discovery/ReflectionHookDiscoveryService.cs b/TUnit.Engine/Discovery/ReflectionHookDiscoveryService.cs
index a9781b19b2..7ac904fb0e 100644
--- a/TUnit.Engine/Discovery/ReflectionHookDiscoveryService.cs
+++ b/TUnit.Engine/Discovery/ReflectionHookDiscoveryService.cs
@@ -1,6 +1,7 @@
 using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using TUnit.Core;
 using TUnit.Core.Hooks;
 using TUnit.Core.Interfaces;
@@ -10,8 +11,13 @@ namespace TUnit.Engine.Discovery;
 /// <summary>
 /// Discovers hooks at runtime using reflection for VB.NET and other languages that don't support source generation.
 /// </summary>
-[RequiresUnreferencedCode("Reflection-based hook discovery requires unreferenced code")]
-[RequiresDynamicCode("Hook invocation may require dynamic code generation")]
+[UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "Reflection mode cannot support trimming")]
+[UnconditionalSuppressMessage("Trimming", "IL2055:Call to 'System.Type.MakeGenericType' can not be statically analyzed", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2067:Target parameter does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2070:Target method does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicMethods' in call to 'System.Type.GetMethods(BindingFlags)'", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "Reflection mode cannot support AOT")]
 internal sealed class ReflectionHookDiscoveryService
 {
     private static readonly ConcurrentDictionary<Assembly, bool> _scannedAssemblies = new();
@@ -19,8 +25,15 @@ internal sealed class ReflectionHookDiscoveryService
 
     public static void DiscoverHooks()
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         var assemblies = AppDomain.CurrentDomain.GetAssemblies();
-        
+
         foreach (var assembly in assemblies)
         {
             if (ShouldScanAssembly(assembly))
@@ -44,7 +57,7 @@ private static bool ShouldScanAssembly(Assembly assembly)
         }
 
         // Skip system and framework assemblies
-        if (name.StartsWith("System.") || 
+        if (name.StartsWith("System.") ||
             name.StartsWith("Microsoft.") ||
             name == "mscorlib" ||
             name == "netstandard" ||
@@ -54,9 +67,9 @@ private static bool ShouldScanAssembly(Assembly assembly)
         }
 
         // Skip TUnit framework assemblies (but not test projects)
-        if (name == "TUnit" || 
-            name == "TUnit.Core" || 
-            name == "TUnit.Engine" || 
+        if (name == "TUnit" ||
+            name == "TUnit.Core" ||
+            name == "TUnit.Engine" ||
             name == "TUnit.Assertions")
         {
             return false;
@@ -92,7 +105,7 @@ private static void DiscoverHooksInAssembly(Assembly assembly)
         try
         {
             var types = assembly.GetTypes();
-            
+
             foreach (var type in types)
             {
                 DiscoverHooksInType(type, assembly);
@@ -107,7 +120,7 @@ private static void DiscoverHooksInAssembly(Assembly assembly)
     private static void DiscoverHooksInType(Type type, Assembly assembly)
     {
         var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
-        
+
         foreach (var method in methods)
         {
             // Check for Before attributes
@@ -144,7 +157,7 @@ private static void RegisterBeforeHook(Type type, MethodInfo method, BeforeAttri
     {
         var hookType = attr.HookType;
         var order = attr.Order;
-        
+
         switch (hookType)
         {
             case HookType.Test:
@@ -206,7 +219,7 @@ private static void RegisterAfterHook(Type type, MethodInfo method, AfterAttribu
     {
         var hookType = attr.HookType;
         var order = attr.Order;
-        
+
         switch (hookType)
         {
             case HookType.Test:
@@ -268,7 +281,7 @@ private static void RegisterBeforeEveryHook(Type type, MethodInfo method, Before
     {
         var hookType = attr.HookType;
         var order = attr.Order;
-        
+
         switch (hookType)
         {
             case HookType.Test:
@@ -343,7 +356,7 @@ private static void RegisterAfterEveryHook(Type type, MethodInfo method, AfterEv
     {
         var hookType = attr.HookType;
         var order = attr.Order;
-        
+
         switch (hookType)
         {
             case HookType.Test:
@@ -574,7 +587,7 @@ private static Func<object, TestContext, CancellationToken, ValueTask> CreateIns
             }
 
             var result = method.Invoke(instance, args);
-            
+
             if (result is Task task)
             {
                 await task;
@@ -619,7 +632,7 @@ private static Func<T, CancellationToken, ValueTask> CreateHookDelegate<T>(Type
             }
 
             var result = method.Invoke(instance, args);
-            
+
             if (result is Task task)
             {
                 await task;
@@ -664,4 +677,4 @@ public ValueTask ExecuteBeforeTestSessionHook(MethodMetadata testMethod, TestSes
 
     public ValueTask ExecuteAfterTestSessionHook(MethodMetadata testMethod, TestSessionContext context, Func<ValueTask> action)
         => action();
-}
\ No newline at end of file
+}
diff --git a/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs b/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs
index 5017edca0c..9ddeb6675c 100644
--- a/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs
+++ b/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs
@@ -12,9 +12,16 @@
 namespace TUnit.Engine.Discovery;
 
 /// Discovers tests at runtime using reflection with assembly scanning and caching
-[RequiresUnreferencedCode("Reflection-based test discovery requires unreferenced code")]
-[RequiresDynamicCode("Expression compilation requires dynamic code generation")]
-[SuppressMessage("Trimming", "IL2077:Target parameter argument does not satisfy \'DynamicallyAccessedMembersAttribute\' in call to target method. The source field does not have matching annotations.")]
+[UnconditionalSuppressMessage("SingleFile", "IL3000:Avoid accessing Assembly file path when publishing as a single file", Justification = "Reflection mode is not supported in single-file deployments")]
+[UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "Reflection mode cannot support trimming")]
+[UnconditionalSuppressMessage("Trimming", "IL2055:Call to 'System.Type.MakeGenericType' can not be statically analyzed", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2060:Call to method can not be statically analyzed", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2067:Target parameter does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2070:Target method does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' requirements", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicMethods' in call to 'System.Type.GetMethods(BindingFlags)'", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("Trimming", "IL2077:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The source field does not have matching annotations.", Justification = "Reflection mode requires dynamic access")]
+[UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "Reflection mode cannot support AOT")]
 internal sealed class ReflectionTestDataCollector : ITestDataCollector
 {
     private static readonly ConcurrentDictionary<Assembly, bool> _scannedAssemblies = new();
@@ -22,10 +29,10 @@ internal sealed class ReflectionTestDataCollector : ITestDataCollector
     private static readonly Lock _resultsLock = new(); // Only for final results aggregation
     private static readonly ConcurrentDictionary<Assembly, Type[]> _assemblyTypesCache = new();
     private static readonly ConcurrentDictionary<Type, MethodInfo[]> _typeMethodsCache = new();
-    
+
     private static Assembly[]? _cachedAssemblies;
     private static readonly Lock _assemblyCacheLock = new();
-    
+
     private static Assembly[] GetCachedAssemblies()
     {
         lock (_assemblyCacheLock)
@@ -33,7 +40,7 @@ private static Assembly[] GetCachedAssemblies()
             return _cachedAssemblies ??= AppDomain.CurrentDomain.GetAssemblies();
         }
     }
-    
+
     public static void ClearCaches()
     {
         _scannedAssemblies.Clear();
@@ -75,6 +82,13 @@ private async Task<List<TestMetadata>> ProcessAssemblyAsync(Assembly assembly, S
 
     public async Task<IEnumerable<TestMetadata>> CollectTestsAsync(string testSessionId)
     {
+#if NET
+        if (!RuntimeFeature.IsDynamicCodeSupported)
+        {
+            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
+        }
+#endif
+
         var allAssemblies = GetCachedAssemblies();
         var assembliesList = new List<Assembly>(allAssemblies.Length);
         foreach (var assembly in allAssemblies)
@@ -277,9 +291,7 @@ private static bool ShouldScanAssembly(Assembly assembly)
 
         try
         {
-#pragma warning disable IL3000 // Avoid accessing Assembly file path when publishing as a single file
             var location = assembly.Location;
-#pragma warning restore IL3000 // Avoid accessing Assembly file path when publishing as a single file
             if (!string.IsNullOrEmpty(location) &&
                 (location.Contains("ref") ||
                     location.Contains("runtimes") ||
@@ -306,7 +318,7 @@ private static bool ShouldScanAssembly(Assembly assembly)
                 break;
             }
         }
-        
+
         if (!hasTUnitReference)
         {
             return false;
@@ -315,12 +327,6 @@ private static bool ShouldScanAssembly(Assembly assembly)
         return true;
     }
 
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
-        Justification = "Reflection mode cannot support trimming")]
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicMethods' in call to 'System.Type.GetMethods(BindingFlags)'",
-        Justification = "Reflection mode requires dynamic access")]
     private static async Task<List<TestMetadata>> DiscoverTestsInAssembly(Assembly assembly)
     {
         var discoveredTests = new List<TestMetadata>(100);
@@ -419,12 +425,6 @@ private static async Task<List<TestMetadata>> DiscoverTestsInAssembly(Assembly a
         return discoveredTests;
     }
 
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
-        Justification = "Reflection mode cannot support trimming")]
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicMethods' in call to 'System.Type.GetMethods(BindingFlags)'",
-        Justification = "Reflection mode requires dynamic access")]
     private static async IAsyncEnumerable<TestMetadata> DiscoverTestsInAssemblyStreamingAsync(
         Assembly assembly,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
@@ -564,11 +564,6 @@ private static async IAsyncEnumerable<TestMetadata> DiscoverTestsInAssemblyStrea
         }
     }
 
-    [UnconditionalSuppressMessage("Trimming", "IL2055:Call to 'System.Type.MakeGenericType' can not be statically analyzed",
-        Justification = "Reflection mode requires dynamic access")]
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2067:'type' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicParameterlessConstructor' in call to 'System.Activator.CreateInstance(Type)'",
-        Justification = "Reflection mode requires dynamic access")]  
     private static async Task<List<TestMetadata>> DiscoverGenericTests(Type genericTypeDefinition)
     {
         var discoveredTests = new List<TestMetadata>(100);
@@ -658,11 +653,6 @@ private static async Task<List<TestMetadata>> DiscoverGenericTests(Type genericT
         return discoveredTests;
     }
 
-    [UnconditionalSuppressMessage("Trimming", "IL2055:Call to 'System.Type.MakeGenericType' can not be statically analyzed",
-        Justification = "Reflection mode requires dynamic access")]
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2067:'type' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicParameterlessConstructor' in call to 'System.Activator.CreateInstance(Type)'",
-        Justification = "Reflection mode requires dynamic access")]
     private static async IAsyncEnumerable<TestMetadata> DiscoverGenericTestsStreamingAsync(
         Type genericTypeDefinition,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
@@ -914,12 +904,6 @@ private static string GenerateTestName(Type testClass, MethodInfo testMethod)
 
 
 
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2070:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicConstructors' in call to 'System.Type.GetConstructors()'",
-        Justification = "Reflection mode requires dynamic access")]
-    [UnconditionalSuppressMessage("Trimming",
-        "IL2067:Target parameter does not satisfy annotation requirements",
-        Justification = "Reflection mode requires dynamic access")]
     private static Func<Type[], object?[], object> CreateInstanceFactory([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type testClass)
     {
         // For generic types, we need to handle MakeGenericType
@@ -1177,7 +1161,6 @@ public override Func<ExecutableTestCreationContext, TestMetadata, AbstractExecut
     /// <summary>
     /// Creates a reflection-based instance factory with proper AOT attribution
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming", "IL2067:Target parameter does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
     private static Func<object?[], object> CreateReflectionInstanceFactory(ConstructorInfo ctor)
     {
         var isPrepared = false;
@@ -1378,8 +1361,6 @@ private static bool IsCovariantCompatible(Type paramType, Type argType)
     /// <summary>
     /// Creates a reflection-based test invoker with proper AOT attribution
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming", "IL2070:Target method does not satisfy annotation requirements", Justification = "Reflection mode requires dynamic access")]
-    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "Reflection mode cannot support AOT")]
     private static Func<object, object?[], Task> CreateReflectionTestInvoker(Type testClass, MethodInfo testMethod)
     {
         var isPrepared = false;
@@ -1457,13 +1438,13 @@ private static bool IsCovariantCompatible(Type paramType, Type argType)
                 // Check if the last parameter is a params array
                 var lastParam = parameters.Length > 0 ? parameters[^1] : null;
                 var isParamsArray = lastParam != null && lastParam.IsDefined(typeof(ParamArrayAttribute), false);
-                
+
                 if (isParamsArray && lastParam != null)
                 {
                     // Handle params array parameter
                     var paramsElementType = lastParam.ParameterType.GetElementType();
                     var regularParamsCount = parameters.Length - 1;
-                    
+
                     // Process regular parameters first
                     for (var i = 0; i < regularParamsCount && i < args.Length; i++)
                     {
@@ -1495,11 +1476,11 @@ private static bool IsCovariantCompatible(Type paramType, Type argType)
                             castedArgs[i] = CastHelper.Cast(paramType, arg);
                         }
                     }
-                    
+
                     // Collect remaining arguments into params array
                     var paramsStartIndex = regularParamsCount;
                     var paramsCount = Math.Max(0, args.Length - paramsStartIndex);
-                    
+
                     if (paramsElementType != null)
                     {
                         var paramsArray = Array.CreateInstance(paramsElementType, paramsCount);
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
index 46cd1ed6cb..33cb8d502b 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
@@ -5,34 +5,39 @@ namespace
     {
         public static void Fail(string reason) { }
         public static  Multiple() { }
-        public static .<> That( action, [.("action")] string? doNotPopulateThisValue = null) { }
-        public static .<.<object>, object> That(.IEnumerable enumerable, [.("enumerable")] string? doNotPopulateThisValue = null) { }
-        public static .<<.>> That(<.> asyncAction, [.("asyncAction")] string? doNotPopulateThisValue = null) { }
-        public static .<<.>> That(. task, [.("task")] string? doNotPopulateThisValue = null) { }
-        public static .<<.>> That(. valueTask, [.("valueTask")] string? doNotPopulateThisValue = null) { }
-        public static .<.<T>, T> That<T>(.<T> enumerable, [.("enumerable")] string? doNotPopulateThisValue = null) { }
-        public static .<.<T>, T> That<T>(.<T> list, [.("list")] string? doNotPopulateThisValue = null) { }
-        public static .<.<T>, T> That<T>(<.<T>> func, [.("func")] string? doNotPopulateThisValue = null) { }
-        public static .<.<T>, T> That<T>(<.<T>> func, [.("func")] string? doNotPopulateThisValue = null) { }
-        public static .<.<T>, T> That<T>(<.<.<T>>> asyncFunc, [.("asyncFunc")] string? doNotPopulateThisValue = null) { }
-        public static .<.<T>, T> That<T>(<.<.<T>>> asyncFunc, [.("asyncFunc")] string? doNotPopulateThisValue = null) { }
-        public static .<T> That<T>(<.<T>> asyncFunc, [.("asyncFunc")] string? doNotPopulateThisValue = null) { }
-        public static .<TElement[], TElement> That<TElement>(<.<TElement[]>> asyncFunc, [.("asyncFunc")] string? doNotPopulateThisValue = null) { }
-        public static .<T> That<T>(<T> func, [.("func")] string? doNotPopulateThisValue = null) { }
-        public static .<TElement[], TElement> That<TElement>(<TElement[]> func, [.("func")] string? doNotPopulateThisValue = null) { }
-        public static .<T> That<T>(.<T> task, [.("task")] string? doNotPopulateThisValue = null) { }
-        public static .<T> That<T>(.<T> valueTask, [.("valueTask")] string? doNotPopulateThisValue = null) { }
+        public static . That( value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static .<.<object>> That(.IEnumerable enumerable, [.("enumerable")] string? doNotPopulateThisValue = null) { }
+        public static . That(<.> value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static . That(. value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static . That(. value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> That<TActual>(<.<TActual>> value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> That<TActual>(<TActual> value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> That<TActual>(.<TActual> value, [.("value")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> That<TActual>(.<TActual> value, [.("value")] string? doNotPopulateThisValue = null) { }
         public static .<TActual> That<TActual>(TActual value, [.("value")] string? doNotPopulateThisValue = null) { }
-        public static .<TElement[], TElement> That<TElement>(TElement[] array, [.("array")] string? doNotPopulateThisValue = null) { }
-        public static . Throws( @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
-        public static . Throws( exceptionType,  @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
-        public static .<TException> Throws<TException>( @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
+        public static  Throws( @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static  Throws( type,  @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static TException Throws<TException>( @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
             where TException :  { }
-        public static . ThrowsAsync(<.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
-        public static . ThrowsAsync(. task, [.("task")] string? doNotPopulateThisValue = null) { }
-        public static . ThrowsAsync(. valueTask, [.("valueTask")] string? doNotPopulateThisValue = null) { }
-        public static . ThrowsAsync( exceptionType, <.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
-        public static .<TException> ThrowsAsync<TException>(<.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
+        public static TException Throws<TException>(string parameterName,  @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
+            where TException :  { }
+        public static .<object?, > ThrowsAsync(<.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, > ThrowsAsync(. @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, > ThrowsAsync(. @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, > ThrowsAsync( type, <.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, > ThrowsAsync( type, . @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, > ThrowsAsync( type, . @delegate, [.("delegate")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, TException> ThrowsAsync<TException>(<.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
+            where TException :  { }
+        public static .<object?, TException> ThrowsAsync<TException>(. @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
+            where TException :  { }
+        public static .<object?, TException> ThrowsAsync<TException>(. @delegate, [.("delegate")] string? doNotPopulateThisValue = null)
+            where TException :  { }
+        public static .<object?, TException> ThrowsAsync<TException>(string parameterName, <.> @delegate, [.("delegate")] string? doNotPopulateThisValue = null, [.("parameterName")] string? doNotPopulateThisValue2 = null)
+            where TException :  { }
+        public static .<object?, TException> ThrowsAsync<TException>(string parameterName, . @delegate, [.("delegate")] string? doNotPopulateThisValue = null, [.("parameterName")] string? doNotPopulateThisValue2 = null)
+            where TException :  { }
+        public static .<object?, TException> ThrowsAsync<TException>(string parameterName, . @delegate, [.("delegate")] string? doNotPopulateThisValue = null, [.("parameterName")] string? doNotPopulateThisValue2 = null)
             where TException :  { }
     }
     public readonly struct AssertionData : <.AssertionData>
@@ -58,6 +63,13 @@ namespace
         public required  EndTime { get; init; }
         public required  StartTime { get; init; }
     }
+    public class CollectionWrapper<TInner>
+    {
+        public CollectionWrapper(..IValueSource<.<TInner>> valueSource) { }
+        public .<.<TInner>> Satisfy(<..IValueSource<TInner?>, .> assert, [.("assert")] string assertionBuilderExpression = "") { }
+        public .<.<TInner>> Satisfy<TExpected>(<TInner?, .<TExpected>?> asyncMapper, <..IValueSource<TExpected?>, .> assert, [.("asyncMapper")] string mapperExpression = "", [.("assert")] string assertionBuilderExpression = "") { }
+        public .<.<TInner>> Satisfy<TExpected>(<TInner?, TExpected> mapper, <..IValueSource<TExpected?>, .> assert, [.("mapper")] string mapperExpression = "", [.("assert")] string assertionBuilderExpression = "") { }
+    }
     public static class Compare
     {
         public static .<.ComparisonFailure> CheckEquivalent<TActual, TExpected>(TActual actual, TExpected expected, .CompareOptions options, int? index) { }
@@ -164,6 +176,13 @@ namespace .AssertConditions
         protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
         public void WithComparer(<TException?, .AssertionDecision> comparer) { }
     }
+    public class EnumerableSatisfiesAssertCondition<TActual, TInner, TExpected> : .<TActual>
+        where TActual : .<TInner?>
+    {
+        public EnumerableSatisfiesAssertCondition(<TInner?, .<TExpected>?> mapper, <..IValueSource<TExpected?>, .> assertionBuilder, string mapperExpression, string assertionBuilderExpression) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
     public abstract class ExpectedExceptionDelegateAssertCondition<TException> : .<object?, >
     {
         protected ExpectedExceptionDelegateAssertCondition() { }
@@ -210,6 +229,12 @@ namespace .AssertConditions
         protected override string GetExpectation() { }
         protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
+    public class SatisfiesAssertCondition<TActual, TExpected> : .<TActual>
+    {
+        public SatisfiesAssertCondition(<TActual, .<TExpected>?> mapper, <..IValueSource<TExpected?>, .<TExpected?>> assertionBuilder, string mapperExpression, string assertionBuilderExpression) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
     public class StaticMethodAssertCondition<T> : .<T>
     {
         public StaticMethodAssertCondition(<T, bool> predicate, string methodName, bool negated = false) { }
@@ -246,6 +271,151 @@ namespace .AssertConditions
     }
 }
 namespace .
+{
+    public class DateTimeEqualsExpectedValueAssertCondition : .<, >
+    {
+        public DateTimeEqualsExpectedValueAssertCondition( expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue,  expectedValue) { }
+        public void SetTolerance( tolerance) { }
+    }
+    public class DateTimeOffsetEqualsExpectedValueAssertCondition : .<, >
+    {
+        public DateTimeOffsetEqualsExpectedValueAssertCondition( expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue,  expectedValue) { }
+        public void SetTolerance( tolerance) { }
+    }
+    public class TimeSpanEqualsExpectedValueAssertCondition : .<, >
+    {
+        public TimeSpanEqualsExpectedValueAssertCondition( expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue,  expectedValue) { }
+        public void SetTolerance( tolerance) { }
+    }
+}
+namespace .
+{
+    public class Member<TActualRootType, TPropertyType>
+    {
+        public Member(..IValueSource<TActualRootType> valueSource, .<<TActualRootType, TPropertyType>> selector) { }
+        public .<TActualRootType> EqualTo(TPropertyType expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActualRootType> NotEqualTo(TPropertyType expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+    }
+    public class PropertyEqualsExpectedValueAssertCondition<TRootObjectType, TPropertyType> : .<TRootObjectType, TPropertyType>
+    {
+        public PropertyEqualsExpectedValueAssertCondition(.<<TRootObjectType, TPropertyType>> propertySelector, TPropertyType expected, bool isEqual) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TRootObjectType? actualValue, TPropertyType? expectedValue) { }
+    }
+}
+namespace .
+{
+    public class EnumerableAllExpectedFuncAssertCondition<TActual, TInner> : .<TActual>
+        where TActual : .<TInner>
+    {
+        public EnumerableAllExpectedFuncAssertCondition(<TInner, bool> matcher, string? matcherString) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumerableContainsExpectedFuncAssertCondition<TActual, TInner> : .<TActual>
+        where TActual : .<TInner>
+    {
+        public EnumerableContainsExpectedFuncAssertCondition(<TInner, bool> matcher, string? matcherString) { }
+        public TInner FoundItem { get; }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumerableContainsExpectedValueAssertCondition<TActual, TInner> : .<TActual, TInner>
+        where TActual : .<TInner>
+    {
+        public EnumerableContainsExpectedValueAssertCondition(TInner expected, .<TInner?>? equalityComparer) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TInner? inner) { }
+    }
+    public class EnumerableCountEqualToExpectedValueAssertCondition<TActual, TInner> : .<TActual, int>
+        where TActual : .<TInner>
+    {
+        public EnumerableCountEqualToExpectedValueAssertCondition(int expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, int count) { }
+    }
+    public class EnumerableCountNotEqualToExpectedValueAssertCondition<TActual, TInner> : .<TActual, int>
+        where TActual : .<TInner>
+    {
+        public EnumerableCountNotEqualToExpectedValueAssertCondition(int expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, int count) { }
+    }
+    public class EnumerableDistinctItemsExpectedValueAssertCondition<TActual, TInner> : .<TActual>
+        where TActual : .<TInner>
+    {
+        public EnumerableDistinctItemsExpectedValueAssertCondition(.<TInner?>? equalityComparer) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumerableEquivalentToExpectedValueAssertCondition<TActual, TInner> : .<TActual, .<TInner>>
+        where TActual : .<TInner>?
+    {
+        public EnumerableEquivalentToExpectedValueAssertCondition(.<TInner>? expected, .<TInner?> equalityComparer, . collectionOrdering) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, .<TInner>? expectedValue) { }
+    }
+    public class EnumerableNotContainsExpectedFuncAssertCondition<TActual, TInner> : .<TActual>
+        where TActual : .<TInner>
+    {
+        public EnumerableNotContainsExpectedFuncAssertCondition(<TInner, bool> matcher, string? matcherString) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumerableNotContainsExpectedValueAssertCondition<TActual, TInner> : .<TActual, TInner>
+        where TActual : .<TInner>
+    {
+        public EnumerableNotContainsExpectedValueAssertCondition(TInner expected, .<TInner?>? equalityComparer) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TInner? inner) { }
+    }
+    public class EnumerableNotEquivalentToExpectedValueAssertCondition<TActual, TInner> : .<TActual, .<TInner>>
+        where TActual : .<TInner>?
+    {
+        public EnumerableNotEquivalentToExpectedValueAssertCondition(.<TInner>? expected, .<TInner?> equalityComparer, . collectionOrdering) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, .<TInner>? expectedValue) { }
+    }
+    public class EnumerableOrderedByAssertCondition<TActual, TInner, TComparisonItem> : .<TActual>
+        where TActual : .<TInner>
+    {
+        public EnumerableOrderedByAssertCondition(.<TComparisonItem?> comparer, <TInner, TComparisonItem> comparisonItemSelector, . order) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class PropertyOrMethodAccessor<TActual>
+    {
+        public PropertyOrMethodAccessor() { }
+    }
+}
+namespace .
+{
+    public class BetweenAssertCondition<TActual> : .<TActual>
+        where TActual : <TActual>
+    {
+        public BetweenAssertCondition(TActual minimum, TActual maximum) { }
+        public void Exclusive() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+        public void Inclusive() { }
+    }
+    public class NotBetweenAssertCondition<TActual> : .<TActual>
+        where TActual : <TActual>
+    {
+        public NotBetweenAssertCondition(TActual minimum, TActual maximum) { }
+        public void Exclusive() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+        public void Inclusive() { }
+    }
+}
+namespace .
 {
     public class ExceptionMessageContainingExpectedValueAssertCondition<TException> : .<TException, string>
         where TException : 
@@ -282,15 +452,30 @@ namespace .
         protected override string GetExpectation() { }
         protected override .<.> GetResult(TException? actualValue, string? expectedValue) { }
     }
-    public class ExceptionTypeAssertCondition : .<, >
-    {
-        public ExceptionTypeAssertCondition( expectedType) { }
-        protected override string GetExpectation() { }
-        protected override .<.> GetResult(? actualValue, ? expectedValue) { }
-    }
 }
 namespace .
 {
+    public class ConvertedDelegateSource<TToType> : ..ISource, ..IValueSource<TToType?>
+        where TToType : 
+    {
+        public ConvertedDelegateSource(..IDelegateSource source) { }
+        public string? ActualExpression { get; }
+        public .<.AssertionData> AssertionDataTask { get; }
+        public .<.> Assertions { get; }
+        public .StringBuilder ExpressionBuilder { get; }
+        public ..ISource AppendExpression(string expression) { }
+        public ..ISource WithAssertion(. assertCondition) { }
+    }
+    public class ConvertedValueSource<TFromType, TToType> : ..ISource, ..IValueSource<TToType?>
+    {
+        public ConvertedValueSource(..IValueSource<TFromType> source, .<TFromType, TToType> convertToAssertCondition) { }
+        public string? ActualExpression { get; }
+        public .<.AssertionData> AssertionDataTask { get; }
+        public .<.> Assertions { get; }
+        public .StringBuilder ExpressionBuilder { get; }
+        public ..ISource AppendExpression(string expression) { }
+        public ..ISource WithAssertion(. assertCondition) { }
+    }
     public interface IDelegateSource : ..ISource { }
     public interface ISource
     {
@@ -339,1036 +524,608 @@ namespace .
         public ValueOr(. assertionBuilder) { }
     }
 }
+namespace .
+{
+    public class StringEqualsExpectedValueAssertCondition : .<string, string>
+    {
+        public StringEqualsExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, string? expectedValue) { }
+        public ..StringEqualsExpectedValueAssertCondition IgnoringWhitespace() { }
+        public ..StringEqualsExpectedValueAssertCondition WithNullAndEmptyEquality() { }
+        public ..StringEqualsExpectedValueAssertCondition WithTrimming() { }
+    }
+    public class StringNotContainsExpectedValueAssertCondition : .<string, string>
+    {
+        public StringNotContainsExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, string? expectedValue) { }
+    }
+    public class StringNotEqualsExpectedValueAssertCondition : .<string, string>
+    {
+        public StringNotEqualsExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, string? expectedValue) { }
+    }
+}
+namespace .
+{
+    public class ThrowsAnyExceptionAssertCondition<TActual> : .<TActual, >
+    {
+        public ThrowsAnyExceptionAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsExactTypeOfDelegateAssertCondition<TActual, TExpectedException> : .<TActual, TExpectedException>
+        where TExpectedException : 
+    {
+        public ThrowsExactTypeOfDelegateAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsNothingAssertCondition<TActual> : .<TActual, >
+    {
+        public ThrowsNothingAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsOfTypeAssertCondition : .<object?, >
+    {
+        public ThrowsOfTypeAssertCondition( type) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(object? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsOfTypeAssertCondition<TActual, TExpectedException> : .<TActual, TExpectedException>
+        where TExpectedException : 
+    {
+        public ThrowsOfTypeAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsWithMessageAssertCondition<TActual, TException> : .<TActual, >
+        where TException : 
+    {
+        public ThrowsWithMessageAssertCondition(string expectedMessage,  stringComparison, <?, ?> exceptionSelector) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsWithMessageContainingAssertCondition<TActual, TException> : .<TActual, >
+        where TException : 
+    {
+        public ThrowsWithMessageContainingAssertCondition(string expected,  stringComparison, <?, ?> exceptionSelector) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsWithMessageMatchingAssertCondition<TActual, TException> : .<TActual, >
+        where TException : 
+    {
+        public ThrowsWithMessageMatchingAssertCondition(. match, <?, ?> exceptionSelector) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsWithMessageNotContainingAssertCondition<TActual, TException> : .<TActual, >
+        where TException : 
+    {
+        public ThrowsWithMessageNotContainingAssertCondition(string expected,  stringComparison, <?, ?> exceptionSelector) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsWithParamNameAssertCondition<TActual, TException> : .<TActual, >
+        where TException : 
+    {
+        public ThrowsWithParamNameAssertCondition(string expectedParamName,  stringComparison, <?, ?> exceptionSelector) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsWithinAssertCondition<TActual, TExpectedException> : .<TActual, TExpectedException>
+        where TExpectedException : 
+    {
+        public ThrowsWithinAssertCondition( timeSpan) { }
+        public override ? WaitFor { get; }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+}
 namespace .AssertionBuilders
 {
-    public abstract class AssertionBase
-    {
-        protected AssertionBase() { }
-        public abstract . ExecuteAsync();
-        public abstract . GetAwaiter();
-    }
-    public abstract class AssertionBase<T> : .
-    {
-        protected AssertionBase(<.<T>> actualValueProvider) { }
-        protected AssertionBase(<T> actualValueProvider) { }
-        protected AssertionBase(.<T> actualValueTask) { }
-        protected AssertionBase(T actualValue) { }
-        public virtual .<T> And { get; }
-        public virtual .<T> Or { get; }
-        protected abstract .<.> AssertAsync();
-        public virtual .<T> Because(string reason, [.("reason")] string? expression = null) { }
-        public override . ExecuteAsync() { }
-        protected .<T> GetActualValueAsync() { }
-        public override . GetAwaiter() { }
-    }
-    public abstract class AssertionBuilder : .
-    {
-        protected AssertionBuilder() { }
-        public virtual string? ActualExpression { get; protected set; }
-        public virtual void AppendExpression(string expression) { }
+    public class AndAssertionBuilder : ., . { }
+    public abstract class AssertionBuilder : ..ISource
+    {
+        protected .AssertionData? AwaitedAssertionData;
+        protected .? OtherTypeAssertionBuilder;
+        protected readonly .<.> Results;
+        public AssertionBuilder(..ISource source) { }
+        public AssertionBuilder(.<.AssertionData> assertionDataTask, string? actualExpression) { }
+        public AssertionBuilder(.<.AssertionData> assertionDataTask, string actualExpression, .StringBuilder expressionBuilder, .<.> assertions) { }
+        protected void AppendCallerMethod(string?[] expressions, [.] string methodName = "") { }
         [.DebuggerHidden]
         [("This is a base `object` method that should not be called.", true)]
         public new void Equals(object? obj) { }
-        public abstract .<.AssertionData> GetAssertionData();
-        public virtual .<.> GetAssertions() { }
-        public abstract . GetAwaiter();
-        public virtual .? GetLastAssertion() { }
-        public abstract . ProcessAssertionsAsync(.AssertionData data);
         [.DebuggerHidden]
         [("This is a base `object` method that should not be called.", true)]
         public void ReferenceEquals(object a, object b) { }
-        public virtual void SetBecause(string reason, string? expression) { }
-        public virtual void WithAssertion(. assertion) { }
-    }
-    public class AssertionBuilder<TActual>
-    {
-        public AssertionBuilder(<.<TActual>> asyncValueProvider, string? expression = null) { }
-        public AssertionBuilder(<TActual> valueProvider, string? expression = null) { }
-        public AssertionBuilder(.<TActual> task, string? expression = null) { }
-        public AssertionBuilder(.<TActual> valueTask, string? expression = null) { }
-        public AssertionBuilder(TActual value, string? expression = null) { }
-        public .<TActual> And { get; }
-        public .<TActual> AssertHasSingleItem() { }
-        public .<TActual> Contains(<object?, bool> predicate) { }
-        public .<TActual> Contains(object? item) { }
-        public .<.<TItem>, TItem> Contains<TItem>(<TItem, bool> predicate) { }
-        public .<TActual> DoesNotContain(object? item) { }
-        public .<TActual> DoesNotContain<TElement>(<TElement, bool> predicate) { }
-        public .<TActual> EqualTo(TActual expected) { }
-        public .<TActual> GetAwaiter() { }
-        public .<TActual> GreaterThanOrEqualTo(TActual value) { }
-        public .<int> HasCount() { }
-        public .<TActual> HasCount(int expectedCount) { }
-        public .<TActual> HasDistinctItems() { }
-        public .<TActual> IsAssignableTo( expectedType) { }
-        public .<TActual> IsAssignableTo<TExpected>() { }
-        public .<TActual> IsEmpty() { }
-        public .<TActual> IsEqualTo(TActual expected) { }
-        public .<TActual> IsEqualTo(object? expected) { }
-        public .<TActual> IsEqualTo(TActual expected, .<TActual> comparer) { }
-        public .<TActual> IsEqualTo(TActual expected, string because) { }
-        public .<TActual> IsEquatableOrEqualTo(TActual expected) { }
-        public .<TActual> IsEquivalentTo(.<object?> expected) { }
-        public .<TActual> IsEquivalentTo(TActual expected) { }
-        public .<TActual> IsEquivalentTo(object? expected) { }
-        public .<TActual> IsEquivalentTo<TElement>(.<TElement> expected, .<TElement> comparer) { }
-        public .<TActual> IsEquivalentTo<TElement>(.<TElement> expected, . ordering) { }
-        public . IsFalse() { }
-        public .<TActual> IsGreaterThan(TActual value) { }
-        public .<TActual> IsGreaterThanOrEqualTo(TActual value) { }
-        public .<TActual> IsIn(.<TActual> values) { }
-        public .<TActual> IsIn(params TActual[] values) { }
-        public .<TActual> IsLessThan(TActual value) { }
-        public .<TActual> IsLessThanOrEqualTo(TActual value) { }
-        public .<TActual> IsNegative() { }
-        public .<TActual> IsNotAssignableTo( expectedType) { }
-        public .<TActual> IsNotAssignableTo<TExpected>() { }
-        public .<TActual> IsNotEmpty() { }
-        public .<TActual> IsNotEqualTo(TActual expected) { }
-        public .<TActual> IsNotEquivalentTo(TActual expected) { }
-        public .<TActual> IsNotEquivalentTo(object? expected) { }
-        public .<TActual> IsNotEquivalentTo<TElement>(.<TElement> expected, . ordering) { }
-        public .<TActual> IsNotIn(params TActual[] values) { }
-        public .<TActual> IsNotNull() { }
-        public .<TActual> IsNull() { }
-        public .<TActual> IsPositive() { }
-        public . IsTrue() { }
-        public .<TActual> IsTypeOf( expectedType) { }
-        public .<TExpected> IsTypeOf<TExpected>()
-            where TExpected :  class { }
-        public .<TActual> Satisfies(<TActual, bool> predicate, string? failureMessage = null) { }
-        public .<TActual, TProperty> Satisfies<TProperty>(<TActual, .<TProperty>> propertySelector, <.<TProperty>, .> assertionBuilder) { }
-        public .<TActual> Satisfies<TConverted>(<TActual, TConverted> converter, <.<TConverted>, .<TConverted>> assertionBuilder) { }
-        public .<TActual, TProperty> Satisfies<TProperty>(<TActual, TProperty> propertySelector, <.<TProperty>, .> assertionBuilder) { }
-        public . Throws( exceptionType) { }
-        public .<TException> Throws<TException>()
-            where TException :  { }
-        public .<TException> ThrowsExactly<TException>()
-            where TException :  { }
-        public . ThrowsException() { }
-        public .<TException> ThrowsException<TException>()
-            where TException :  { }
-        public .<TActual> ThrowsNothing() { }
-        public .<TResult> ThrowsNothing<TResult>() { }
     }
-    public class AssertionChainBuilder<T> : .<T>
+    public class AsyncDelegateAssertionBuilder : ., ..IDelegateSource, ..ISource { }
+    public class AsyncValueDelegateAssertionBuilder<TActual> : ., ..IDelegateSource, ..ISource, ..IValueDelegateSource<TActual>, ..IValueSource<TActual> { }
+    public class CastableResultAssertionBuilder<TActual, TExpected> : .<TActual, TExpected> { }
+    public class CastedAssertionBuilder<TActual, TExpected> : .<TExpected> { }
+    public class ConvertedDelegateAssertionBuilder<TException> : .<TException>
+        where TException : 
     {
-        public new .<T> Contains(object? item) { }
-        public new .<T> HasCount(int expectedCount) { }
-        public new .<T> IsEmpty() { }
-        public new .<T> IsEqualTo(T expected) { }
-        public new .<T> IsFalse() { }
-        public new .<T> IsNotEmpty() { }
-        public new .<T> IsNotEqualTo(T expected) { }
-        public new .<T> IsNotNull() { }
-        public new .<T> IsNull() { }
-        public new .<T> IsTrue() { }
-        public new .<T> Satisfies(<T, bool> predicate, string? failureMessage = null) { }
+        public ConvertedDelegateAssertionBuilder(..IDelegateSource source) { }
     }
-    public class AssertionEvaluator
+    public class ConvertedValueAssertionBuilder<TFromType, TToType> : .<TToType>
     {
-        public AssertionEvaluator() { }
-        public . EvaluateAsync(..IAssertionChain chain) { }
-        public .<.AssertionData> EvaluateAsync(.<.AssertionData> assertionDataTask, .<.> assertions, . expressionFormatter) { }
-        public .<.> GetResults() { }
+        public ConvertedValueAssertionBuilder(..IValueSource<TFromType> source, .<TFromType, TToType> convertToAssertCondition) { }
     }
-    public static class BetweenAssertionExtensions
+    public class DelegateAssertionBuilder : ., ..IDelegateSource, ..ISource { }
+    public interface IAndAssertionBuilder { }
+    public interface IInvokableAssertionBuilder : ..ISource
     {
-        public static .<TActual> IsBetween<TActual>(this .<TActual> builder, TActual min, TActual max, bool inclusive = true)
-            where TActual : <TActual> { }
-        public static .<TActual> IsNotBetween<TActual>(this .<TActual> builder, TActual min, TActual max, bool inclusive = true)
-            where TActual : <TActual> { }
+        . GetAwaiter();
+        string? GetExpression();
     }
-    public class BetweenAssertion<TActual> : .<TActual>
-        where TActual : <TActual>
+    public interface IOrAssertionBuilder { }
+    public class InvokableAssertionBuilder<TActual> : ., ..ISource, .
     {
-        public BetweenAssertion(<.<TActual>> actualValueProvider, TActual min, TActual max, bool inclusive = true, bool shouldBeInRange = true) { }
-        public BetweenAssertion(<TActual> actualValueProvider, TActual min, TActual max, bool inclusive = true, bool shouldBeInRange = true) { }
-        public BetweenAssertion(TActual actualValue, TActual min, TActual max, bool inclusive = true, bool shouldBeInRange = true) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class BooleanAssertion : .<bool>
-    {
-        public BooleanAssertion(<.<bool>> actualValueProvider, bool expectedValue) { }
-        public BooleanAssertion(<bool> actualValueProvider, bool expectedValue) { }
-        public BooleanAssertion(bool actualValue, bool expectedValue) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class ChainedAssertion<T> : .<T>
-    {
-        public ChainedAssertion(.<T> baseAssertion) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public static class ChainingExtensions
-    {
-        public static . Chain<T>(this .<T> builder, . other) { }
-        public static .<T> Chain<T>(this .<T> builder, .<T> other) { }
-        public static .<T> CompletesWithin<T>(this .<T> builder,  timeout) { }
-        public static .<T> HasMember<T>(this .<T> builder, string memberName) { }
-        public static .<T, TProperty> HasMember<T, TProperty>(this .<T> builder, <T, TProperty> propertySelector) { }
-        public static .<T> HasMessageContaining<T>(this .<T> builder, string substring)
-            where T :  { }
-        public static .<T> HasMessageEndingWith<T>(this .<T> builder, string suffix)
-            where T :  { }
-        public static .<T> HasMessageEqualTo<T>(this .<T> builder, string expectedMessage)
-            where T :  { }
-        public static .<T> HasMessageStartingWith<T>(this .<T> builder, string prefix)
-            where T :  { }
-        public static .<T> IgnoringMember<T>(this .<T> assertion, string memberName) { }
-        public static .<string> IgnoringWhitespace(this .<string> assertion) { }
-        public static . IgnoringWhitespace(this .<string> assertion) { }
-        public static .<> IsAssignableTo(this . assertion,  targetType) { }
-        public static .<TException> IsAssignableTo<TException>(this .<TException> assertion,  targetType)
-            where TException :  { }
-        public static .<T> IsAssignableTo<T, TTarget>(this .<T> builder) { }
-        public static .<T> IsAssignableTo<T, TTarget>(this .<T> assertion) { }
-        public static .<T> IsDefault<T>(this .<T> builder) { }
-        public static .<T> IsNotDefault<T>(this .<T> builder) { }
-        public static . WithNullAndEmptyEquality(this .<string> assertion) { }
-        public static .<string> WithTrimming(this .<string> assertion) { }
-        public static . WithTrimming(this .<string> assertion) { }
-        public static .<> Within(this .<> assertion,  tolerance) { }
-        public static .<> Within(this .<> assertion,  tolerance) { }
-        public static .<> Within(this .<> assertion,  tolerance) { }
-    }
-    public class CollectionAllAssertion<T> : .<.<T>>
-    {
-        public CollectionAllAssertion(<.<T>> actualValueProvider) { }
-        public CollectionAllAssertion(<.<.<T>>> actualValueProvider) { }
-        protected override .<.> AssertAsync() { }
-        public .<.<T>> Satisfy(<T, bool> predicate) { }
-        public .<T, T> Satisfy(<.<T>, .> assertionBuilder) { }
-        public .<T, TProperty> Satisfy<TProperty>(<T, .<TProperty>> asyncPropertySelector, <.<TProperty>, .> assertionBuilder) { }
-        public .<T, TProperty> Satisfy<TProperty>(<T, TProperty> propertySelector, <.<TProperty>, .> assertionBuilder) { }
-    }
-    public static class CollectionAllExtensions
-    {
-        public static .<T> All<T>(this .<.<T>> builder) { }
-        public static .<T> All<T>(this .<.<T>> builder) { }
-        public static .<T> All<T>(this .<T[]> builder) { }
-    }
-    public enum CollectionAssertType
-    {
-        Empty = 0,
-        NotEmpty = 1,
-        Count = 2,
-        Contains = 3,
-        DoesNotContain = 4,
-        HasSingleItem = 5,
-        HasDistinctItems = 6,
-    }
-    public class CollectionAssertionBuilder<TCollection, TElement> : .<TCollection>
-        where TCollection : .<TElement>
-    {
-        public CollectionAssertionBuilder(<.<TCollection>> asyncValueProvider, string? expression = null) { }
-        public CollectionAssertionBuilder(<TCollection> valueProvider, string? expression = null) { }
-        public CollectionAssertionBuilder(.<TCollection> task, string? expression = null) { }
-        public CollectionAssertionBuilder(.<TCollection> valueTask, string? expression = null) { }
-        public CollectionAssertionBuilder(TCollection value, string? expression = null) { }
-        public .<TElement> All() { }
-        public .<TCollection> All(<TElement, bool> predicate) { }
-        public .<TCollection> Any(<TElement, bool> predicate) { }
-        public .<TCollection, TElement> Contains(<TElement, bool> predicate) { }
-        public .<TCollection> Contains(TElement item) { }
-        public .<TCollection> ContainsOnly(<TElement, bool> predicate) { }
-        public .<TCollection> DoesNotContain(<TElement, bool> predicate) { }
-        public .<TCollection> DoesNotContain(TElement item) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void Equals(object? obj) { }
-        public new .<TCollection> GetAwaiter() { }
-        public .<TElement> GetSingleItem() { }
-        public .<int> HasCount() { }
-        public .<TCollection> HasCount(int expectedCount) { }
-        public .<TCollection> HasDistinctItems() { }
-        public .<TCollection> HasSingleItem() { }
-        public .<TCollection> IsEmpty() { }
-        public .<TCollection> IsEquivalentTo(.<TElement> expected) { }
-        public .<TCollection> IsInDescendingOrder() { }
-        public .<TCollection> IsInOrder() { }
-        public .<TCollection> IsNotEmpty() { }
-        public .<TCollection> None(<TElement, bool> predicate) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void ReferenceEquals(object a, object b) { }
-    }
-    public static class CollectionAssertionExtensions
-    {
-        public static .<T> Contains<T>(this .<T> assertion, <object, bool> predicate) { }
-        public static .<int> HasCount<T>(this .<T> assertion) { }
-        public static .<T> HasCount<T>(this .<T> assertion, int expectedCount) { }
-    }
-    public class CollectionAssertion<TActual> : .<TActual>
-    {
-        public CollectionAssertion(<.<TActual>> actualValueProvider, . assertType, int? expectedCount = default, object? expectedItem = null) { }
-        public CollectionAssertion(<TActual> actualValueProvider, . assertType, int? expectedCount = default, object? expectedItem = null) { }
-        public CollectionAssertion(TActual actualValue, . assertType, int? expectedCount = default, object? expectedItem = null) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public static class CollectionContainsOnlyExtensions
-    {
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, <T, bool> predicate) { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, params T[] expected) { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, <T, bool> predicate) { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, params T[] expected) { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, <T, bool> predicate) { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, <T, bool> predicate) { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, params T[] expected) { }
-        public static .<T[]> ContainsOnly<T>(this .<T[]> builder, <T, bool> predicate) { }
-        public static .<T[]> ContainsOnly<T>(this .<T[]> builder, params T[] expected) { }
-        public static .<.<int>> DoesNotContain(this .<.<int>> builder, <int, bool> predicate) { }
-        public static .<.<int>> DoesNotContain(this .<.<int>> builder, <int, bool> predicate) { }
-        public static .<int[]> DoesNotContain(this .<int[]> builder, <int, bool> predicate) { }
-    }
-    public static class CollectionExtensions
-    {
-        public static .<T> GetSingleItem<T>(this .<.<T>> builder) { }
-        public static .<T> GetSingleItem<T>(this .<.<T>> builder) { }
-        public static .<T> GetSingleItem<T>(this .<.<T>> builder) { }
-        public static .<T> GetSingleItem<T>(this .<.<T>> builder) { }
-        public static .<T> GetSingleItem<T>(this .<.<T>> builder) { }
-        public static .<T> GetSingleItem<T>(this .<.<T>> builder) { }
-        public static .<T> GetSingleItem<T>(this .<T[]> builder) { }
-        public static .<T> HasSingleItem<T>(this .<T> builder)
-            where T : .IEnumerable { }
-    }
-    public static class CollectionOrderingExtensions
-    {
-        public static .<.<T>> IsInDescendingOrder<T>(this .<.<T>> builder)
-            where T : <T> { }
-        public static .<T[]> IsInDescendingOrder<T>(this .<T[]> builder)
-            where T : <T> { }
-        public static .<.<object>> IsInOrder(this .<.<object>> builder) { }
-        public static .<.<T>> IsInOrder<T>(this .<.<T>> builder)
-            where T : <T> { }
-        public static .<T[]> IsInOrder<T>(this .<T[]> builder)
-            where T : <T> { }
-    }
-    public class ComparisonAndChain<TActual>
-    {
-        public ComparisonAndChain(.<TActual> previousAssertion, <.<TActual>> valueProvider) { }
-        public . IsGreaterThan(TActual value) { }
-        public . IsGreaterThanOrEqualTo(TActual value) { }
-        public . IsLessThan(TActual value) { }
-        public . IsLessThanOrEqualTo(TActual value) { }
-    }
-    public class ComparisonAssertion<TActual> : .<TActual>
-    {
-        public ComparisonAssertion(<.<TActual>> actualValueProvider, TActual comparisonValue, . comparisonType) { }
-        public ComparisonAssertion(<TActual> actualValueProvider, TActual comparisonValue, . comparisonType) { }
-        public ComparisonAssertion(TActual actualValue, TActual comparisonValue, . comparisonType) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public enum ComparisonType
-    {
-        GreaterThan = 0,
-        GreaterThanOrEqual = 1,
-        LessThan = 2,
-        LessThanOrEqual = 3,
-    }
-    public class ContainsPredicateAssertion<TCollection, TItem> : .<TCollection>
-        where TCollection : .<TItem>
-    {
-        public ContainsPredicateAssertion(<.<TCollection>> collectionProvider, <TItem, bool> predicate) { }
-        protected override .<.> AssertAsync() { }
-        public new .<TItem?> GetAwaiter() { }
+        protected readonly ..ISource Source;
+        protected .<.> Assertions { get; }
+        public .<.<.>> GetAssertionResults() { }
+        public . GetAwaiter() { }
     }
-    public static class CultureInfoAssertionExtensions
+    public class InvokableDelegateAssertionBuilder : .<object?>, ..IDelegateSource, ..ISource
     {
-        public static .<.CultureInfo> IsEnglish(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsInvariant(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsLeftToRight(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsNeutralCulture(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsNotEnglish(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsNotInvariant(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsNotNeutralCulture(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsReadOnly(this .<.CultureInfo> builder) { }
-        public static .<.CultureInfo> IsRightToLeft(this .<.CultureInfo> builder) { }
-    }
-    public class CustomAssertion<TActual> : .<TActual>
-    {
-        public CustomAssertion(<.<TActual>> actualValueProvider, <TActual, bool> predicate, string? failureMessage) { }
-        public CustomAssertion(<TActual> actualValueProvider, <TActual, bool> predicate, string? failureMessage) { }
-        public CustomAssertion(TActual actualValue, <TActual, bool> predicate, string? failureMessage) { }
-        protected override .<.> AssertAsync() { }
-        public .<TActual> IgnoringType<TIgnore>() { }
-        public .<TActual> WithPartialEquivalency() { }
-    }
-    public class DateTimeAssertion : .<>
-    {
-        public DateTimeAssertion( actualValue,  expected) { }
-        public DateTimeAssertion(<> actualValueProvider,  expected) { }
-        public DateTimeAssertion(<.<>> actualValueProvider,  expected) { }
-        protected override .<.> AssertAsync() { }
-        public .<> IsAfterOrEqualTo( other) { }
-        public .<> IsBeforeOrEqualTo( other) { }
-        public . Within( tolerance) { }
-    }
-    public static class DateTimeAssertionBuilderExtensions
-    {
-        public static .<> IsAfterOrEqualTo(this .<> builder,  other) { }
-        public static .<> IsBeforeOrEqualTo(this .<> builder,  other) { }
-        public static . IsEqualTo(this .<> builder,  expected) { }
-        public static . IsEqualTo(this .<> builder,  expected) { }
-        public static . IsEqualTo(this .<> builder,  expected) { }
-    }
-    public class DateTimeOffsetAssertion : .<>
-    {
-        public DateTimeOffsetAssertion( actualValue,  expected) { }
-        public DateTimeOffsetAssertion(<> actualValueProvider,  expected) { }
-        public DateTimeOffsetAssertion(<.<>> actualValueProvider,  expected) { }
-        protected override .<.> AssertAsync() { }
-        public . Within( tolerance) { }
+        public ..DelegateAnd<object?> And { get; }
+        public . AssertionBuilder { get; }
+        public ..DelegateOr<object?> Or { get; }
     }
-    public static class DayOfWeekAssertionExtensions
+    public class InvokableValueAssertionBuilder<TActual> : .<TActual>, ..ISource, ..IValueSource<TActual>
     {
-        public static .<> IsFriday(this .<> builder) { }
-        public static .<> IsMonday(this .<> builder) { }
-        public static .<> IsSaturday(this .<> builder) { }
-        public static .<> IsSunday(this .<> builder) { }
-        public static .<> IsThursday(this .<> builder) { }
-        public static .<> IsTuesday(this .<> builder) { }
-        public static .<> IsWednesday(this .<> builder) { }
-        public static .<> IsWeekday(this .<> builder) { }
-        public static .<> IsWeekend(this .<> builder) { }
-    }
-    public class DelegateAssertionBuilder<TDelegate> : .
-        where TDelegate : 
-    {
-        protected readonly <.<TDelegate>> _delegateProvider;
-        protected readonly string? _expression;
-        public DelegateAssertionBuilder(<.<TDelegate>> asyncDelegateProvider, string? expression = null) { }
-        public DelegateAssertionBuilder(<TDelegate> delegateProvider, string? expression = null) { }
-        public DelegateAssertionBuilder(.<TDelegate> task, string? expression = null) { }
-        public DelegateAssertionBuilder(.<TDelegate> valueTask, string? expression = null) { }
-        public DelegateAssertionBuilder(TDelegate delegateValue, string? expression = null) { }
-        public .<TDelegate> And { get; }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void Equals(object? obj) { }
-        public override .<.AssertionData> GetAssertionData() { }
-        public override . GetAwaiter() { }
-        public override . ProcessAssertionsAsync(.AssertionData data) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void ReferenceEquals(object a, object b) { }
-        public . Throws( exceptionType) { }
-        public .<TException> Throws<TException>()
-            where TException :  { }
-        public .<TException> ThrowsExactly<TException>()
-            where TException :  { }
-        public . ThrowsException() { }
-        public .<TException> ThrowsException<TException>()
-            where TException :  { }
-        public .<object?> ThrowsNothing() { }
-    }
-    public static class DictionaryAssertionExtensions
-    {
-        public static .<T> ContainsKey<T>(this .<T> builder, object key)
-            where T : .IDictionary { }
-        public static .<T> ContainsKey<T>(this .<T> builder, string key)
-            where T : .<string, string> { }
-        public static .<.<string, TValue>> ContainsKey<TValue>(this .<.<string, TValue>> builder, string key, .<string> comparer) { }
-        public static .<TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key) { }
-        public static .<.<TKey, TValue>> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key) { }
-        public static .<TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key) { }
-        public static .<.<TKey, TValue>> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key) { }
-    }
-    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>>
-    {
-        public DictionaryAssertion(.<TKey, TValue> actualValue, TKey? key, bool shouldContain) { }
-        public DictionaryAssertion(<.<TKey, TValue>> actualValueProvider, TKey? key, bool shouldContain) { }
-        public DictionaryAssertion(<.<.<TKey, TValue>>> actualValueProvider, TKey? key, bool shouldContain) { }
-        protected override .<.> AssertAsync() { }
+        public InvokableValueAssertionBuilder(..ISource source) { }
+        public ..ValueAnd<TActual> And { get; }
+        public ..ValueOr<TActual> Or { get; }
+        public .<TActual> Because(string reason) { }
+        public new .<TActual?> GetAwaiter() { }
     }
-    public static class DirectoryInfoAssertionExtensions
+    public class InvokableValueDelegateAssertionBuilder<TActual> : .<TActual>
     {
-        public static .<.DirectoryInfo> DoesNotExist(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> Exists(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> HasFiles(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> HasNoFiles(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> HasNoSubdirectories(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> HasSubdirectories(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> IsEmpty(this .<.DirectoryInfo> builder) { }
-        public static .<.DirectoryInfo> IsNotEmpty(this .<.DirectoryInfo> builder) { }
-    }
-    public class DualAssertionBuilder<T> : .<T>
-    {
-        public DualAssertionBuilder(<.<T>> asyncFuncValue, string? expression = null) { }
-        public DualAssertionBuilder(<T> funcValue, string? expression = null) { }
-        public DualAssertionBuilder(.<T> task, string? expression = null) { }
-        public DualAssertionBuilder(.<T> valueTask, string? expression = null) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void Equals(object? obj) { }
-        public new .<T> GetAwaiter() { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void ReferenceEquals(object a, object b) { }
-        public . Throws( exceptionType) { }
-        public .<TException> Throws<TException>()
-            where TException :  { }
-        public .<TException> ThrowsExactly<TException>()
-            where TException :  { }
-        public . ThrowsException() { }
-        public .<TException> ThrowsException<TException>()
-            where TException :  { }
-        public .<T> ThrowsNothing() { }
+        public ..ValueDelegateAnd<TActual> And { get; }
+        public . AssertionBuilder { get; }
+        public ..ValueDelegateOr<TActual> Or { get; }
     }
-    public class DualCollectionAssertionBuilder<TCollection, TElement> : .<TCollection, TElement>
-        where TCollection : .<TElement>
+    public class MappableResultAssertionBuilder<TActual, TExpected> : .<TActual>
     {
-        public DualCollectionAssertionBuilder(<.<TCollection>> asyncFuncValue, string? expression = null) { }
-        public DualCollectionAssertionBuilder(<TCollection> funcValue, string? expression = null) { }
-        public DualCollectionAssertionBuilder(.<TCollection> task, string? expression = null) { }
-        public DualCollectionAssertionBuilder(.<TCollection> valueTask, string? expression = null) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void Equals(object? obj) { }
-        public new .<TCollection> GetAwaiter() { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void ReferenceEquals(object a, object b) { }
-        public . Throws( exceptionType) { }
-        public .<TException> Throws<TException>()
-            where TException :  { }
-        public .<TException> ThrowsExactly<TException>()
-            where TException :  { }
-        public . ThrowsException() { }
-        public .<TException> ThrowsException<TException>()
-            where TException :  { }
-        public .<TCollection> ThrowsNothing() { }
+        public MappableResultAssertionBuilder(.<TActual> assertionBuilder, <TActual?, TExpected?> mapper) { }
+        public new .<TExpected?> GetAwaiter() { }
     }
-    public static class EncodingAssertionExtensions
+    public class MappableResultAssertionBuilder<TActual, TAssertCondition, TExpected> : .<TActual>
+        where TAssertCondition : .<TActual>
     {
-        public static .<.Encoding> IsASCII(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsBigEndianUnicode(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsNotSingleByte(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsNotUTF8(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsSingleByte(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsUTF32(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsUTF8(this .<.Encoding> builder) { }
-        public static .<.Encoding> IsUnicode(this .<.Encoding> builder) { }
+        public MappableResultAssertionBuilder(.<TActual> assertionBuilder, TAssertCondition assertCondition, <TActual?, TAssertCondition, TExpected?> mapper) { }
+        public new .<TExpected?> GetAwaiter() { }
     }
-    public class ExceptionAssertion : .<>
+    public class OrAssertionBuilder : ., . { }
+    public class ValueAssertionBuilder<TActual> : ., ..ISource, ..IValueSource<TActual>
     {
-        public ExceptionAssertion( syncDelegate) { }
-        public ExceptionAssertion(<.> asyncDelegate) { }
-        public ExceptionAssertion( syncDelegate,  expectedType) { }
-        public ExceptionAssertion(<.> asyncDelegate,  expectedType) { }
-        public new . WithInnerException() { }
+        public ValueAssertionBuilder(..ISource source) { }
     }
-    public static class ExceptionAssertionExtensions
+    public class ValueDelegateAssertionBuilder<TActual> : ., ..IDelegateSource, ..ISource, ..IValueDelegateSource<TActual>, ..IValueSource<TActual> { }
+}
+namespace .
+{
+    public class AndAssertionGroupInvoker<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public static .<> HasInnerException(this .<> builder) { }
-        public static .<> HasNoData(this .<> builder) { }
-        public static .<> HasNoInnerException(this .<> builder) { }
-        public static .<> HasStackTrace(this .<> builder) { }
+        public AndAssertionGroupInvoker(..AssertionGroup<TActual, TAssertionBuilder> group1, ..AssertionGroup<TActual, TAssertionBuilder> group2) { }
+        public ..AndAssertionGroupInvoker<TActual, TAssertionBuilder> And(..AssertionGroup<TActual, TAssertionBuilder> group) { }
+        public .<TActual?> GetAwaiter() { }
     }
-    public class ExceptionAssertion<TException> : .<TException>
-        where TException : 
+    public class AndAssertionGroup<TActual, TAssertionBuilder> : ..AssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public ExceptionAssertion( syncDelegate) { }
-        public ExceptionAssertion(<.> asyncDelegate) { }
-        public ExceptionAssertion( syncDelegate,  expectedType) { }
-        public ExceptionAssertion(<.> asyncDelegate,  expectedType) { }
-        public new .<TException> And { get; }
-        protected override .<.> AssertAsync() { }
-        public new .<TException> GetAwaiter() { }
-        public .<TException> GetExceptionAsync() { }
-        public .<TException> HasInnerException() { }
-        public .<TException> HasMessageContaining(string substring) { }
-        public .<TException> HasMessageEqualTo(string expectedMessage) { }
-        public .<TException> HasNoInnerException() { }
-        public .<TException> HasStackTrace() { }
-        public .<TException> IsAssignableTo( targetType) { }
-        public .<TException> IsAssignableTo<TTarget>() { }
-        public .<TException> Matching(<TException, bool> predicate) { }
-        public .<TException> WithInnerException() { }
-        public .<TException> WithInnerException<TInner>()
-            where TInner :  { }
-        public .<TException> WithMessage(string expectedMessage) { }
-        public .<TException> WithMessageContaining(string substring) { }
-        public .<TException> WithMessageContaining(string substring,  comparison) { }
-        public .<TException> WithMessageMatching(. matcher) { }
-        public .<TException> WithMessageMatching(string pattern) { }
-        public .<TException> WithMessageNotContaining(string substring) { }
-        public .<TException> WithMessageNotContaining(string substring,  comparison) { }
-        public .<TException> WithParameterName(string parameterName) { }
-        public static .<TException> op_Implicit(.<TException> assertion) { }
-    }
-    public class ExecutionTimeAssertion<T> : .<T>
-    {
-        public ExecutionTimeAssertion(<.<T>> actualValueProvider,  timeout) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class ExpressionFormatter
-    {
-        public ExpressionFormatter(string? actualExpression) { }
-        public string? ActualExpression { get; }
-        public void AppendConnector(string connector) { }
-        public void AppendMethod(string methodName, params string?[] arguments) { }
-        public string GetExpression() { }
+        public ..AndAssertionGroup<TActual, TAssertionBuilder> And(<TAssertionBuilder, .<TActual>> assert) { }
+        public override .<TActual?> GetAwaiter() { }
     }
-    public static class FileInfoAssertionExtensions
+    public static class AssertionGroup
     {
-        public static .<.FileInfo> DoesNotExist(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> Exists(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsEmpty(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsExecutable(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsHidden(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsNotEmpty(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsNotExecutable(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsNotHidden(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsNotReadOnly(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsNotSystem(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsReadOnly(this .<.FileInfo> builder) { }
-        public static .<.FileInfo> IsSystem(this .<.FileInfo> builder) { }
-    }
-    public enum FileSystemAssertType
-    {
-        FileExists = 0,
-        FileDoesNotExist = 1,
-        DirectoryExists = 2,
-        DirectoryDoesNotExist = 3,
-        HasFiles = 4,
-        HasNoFiles = 5,
-        HasSubdirectories = 6,
-        HasNoSubdirectories = 7,
-    }
-    public class FileSystemAssertion : .<string>
-    {
-        public FileSystemAssertion(<.<string>> pathProvider, . assertType) { }
-        public FileSystemAssertion(<string> pathProvider, . assertType) { }
-        public FileSystemAssertion(string path, . assertType) { }
-        protected override .<.> AssertAsync() { }
+        public static ..AndAssertionGroupInvoker<TActual, TAssertionBuilder> And<TActual, TAssertionBuilder>(..AssertionGroup<TActual, TAssertionBuilder> group1, ..AssertionGroup<TActual, TAssertionBuilder> group2)
+            where TAssertionBuilder : . { }
+        public static ..UnknownAssertionGroupInvoker<TActual, TAssertionBuilder> Assert<TActual, TAssertionBuilder>(..AssertionGroup<TActual, TAssertionBuilder> group)
+            where TAssertionBuilder : . { }
+        public static ..AssertionGroupBuilder<object?, .> For( value) { }
+        public static ..AssertionGroupBuilder<object?, .> For(<.> value) { }
+        public static ..AssertionGroupBuilder<object?, .> For(. value) { }
+        public static ..AssertionGroupBuilder<object?, .> For(. value) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> For<TActual>(<.<TActual>> value) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> For<TActual>(<TActual> value) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> For<TActual>(.<TActual> value) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> For<TActual>(.<TActual> value) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> For<TActual>(TActual value) { }
+        public static ..AssertionGroupBuilder<object?, .> ForSameValueAs(..AssertionGroup<object?, .> otherGroup) { }
+        public static ..AssertionGroupBuilder<object?, .> ForSameValueAs(..AssertionGroup<object?, .> otherGroup) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> ForSameValueAs<TActual>(..AssertionGroup<TActual, .<TActual>> otherGroup) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> ForSameValueAs<TActual>(..AssertionGroup<TActual, .<TActual>> otherGroup) { }
+        public static ..AssertionGroupBuilder<TActual, .<TActual>> ForSameValueAs<TActual>(..AssertionGroup<TActual, .<TActual>> otherGroup) { }
+        public static ..OrAssertionGroupInvoker<TActual, TAssertionBuilder> Or<TActual, TAssertionBuilder>(..AssertionGroup<TActual, TAssertionBuilder> group1, ..AssertionGroup<TActual, TAssertionBuilder> group2)
+            where TAssertionBuilder : . { }
     }
-    public static class FileSystemAssertionExtensions
+    public class AssertionGroupBuilder<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public static . DirectoryDoesNotExist(this .<string> builder) { }
-        public static . DirectoryExists(this .<string> builder) { }
-        public static . DoesNotExist(this .<string> builder) { }
-        public static . Exists(this .<string> builder) { }
-        public static . HasFiles(this .<string> builder) { }
-        public static . HasNoFiles(this .<string> builder) { }
-        public static . HasNoSubdirectories(this .<string> builder) { }
-        public static . HasSubdirectories(this .<string> builder) { }
+        public ..UnknownAssertionGroup<TActual, TAssertionBuilder> WithAssertion(<TAssertionBuilder, .<TActual>> assert) { }
     }
-    public class GenericEqualToAssertion<TActual> : .<TActual>
+    public abstract class AssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public GenericEqualToAssertion(<.<TActual>> actualValueProvider, TActual expected) { }
-        public GenericEqualToAssertion(<TActual> actualValueProvider, TActual expected) { }
-        public GenericEqualToAssertion(TActual actualValue, TActual expected) { }
-        protected override .<.> AssertAsync() { }
-        public .<TActual> WithComparer(.<TActual> comparer) { }
-        public .<TActual> WithComparison(<TActual?, TActual?, bool> comparison) { }
+        public abstract .<TActual?> GetAwaiter();
     }
-    public class GenericNotEqualToAssertion<TActual> : .<TActual>
+    public class OrAssertionException : 
     {
-        public GenericNotEqualToAssertion(<.<TActual>> actualValueProvider, TActual expected) { }
-        public GenericNotEqualToAssertion(<TActual> actualValueProvider, TActual expected) { }
-        public GenericNotEqualToAssertion(TActual actualValue, TActual expected) { }
-        protected override .<.> AssertAsync() { }
-        public .<TActual> WithComparer(.<TActual> comparer) { }
+        public OrAssertionException(.<> exceptions) { }
+        public override string Message { get; }
     }
-    public static class HttpStatusCodeAssertionExtensions
+    public class OrAssertionGroupInvoker<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public static .<.HttpStatusCode> IsClientError(this .<.HttpStatusCode> builder) { }
-        public static .<.HttpStatusCode> IsError(this .<.HttpStatusCode> builder) { }
-        public static .<.HttpStatusCode> IsInformational(this .<.HttpStatusCode> builder) { }
-        public static .<.HttpStatusCode> IsNotSuccess(this .<.HttpStatusCode> builder) { }
-        public static .<.HttpStatusCode> IsRedirection(this .<.HttpStatusCode> builder) { }
-        public static .<.HttpStatusCode> IsServerError(this .<.HttpStatusCode> builder) { }
-        public static .<.HttpStatusCode> IsSuccess(this .<.HttpStatusCode> builder) { }
+        public OrAssertionGroupInvoker(..AssertionGroup<TActual, TAssertionBuilder> group1, ..AssertionGroup<TActual, TAssertionBuilder> group2) { }
+        public .<TActual?> GetAwaiter() { }
+        public ..OrAssertionGroupInvoker<TActual, TAssertionBuilder> Or(..AssertionGroup<TActual, TAssertionBuilder> group) { }
     }
-    public interface IInvokableAssertionBuilder
+    public class OrAssertionGroup<TActual, TAssertionBuilder> : ..AssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        .<.AssertionData> GetAssertionData();
-        .<.> GetAssertions();
-        . GetAwaiter();
-        .? GetLastAssertion();
-        . ProcessAssertionsAsync(.AssertionData data);
+        public override .<TActual?> GetAwaiter() { }
+        public ..OrAssertionGroup<TActual, TAssertionBuilder> Or(<TAssertionBuilder, .<TActual>> assert) { }
     }
-    public static class IgnoreType
+    public class UnknownAssertionGroupInvoker<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public static .<T> For<T, TIgnore>(.<T> assertion) { }
+        public UnknownAssertionGroupInvoker(..AssertionGroup<TActual, TAssertionBuilder> group) { }
+        public ..AndAssertionGroupInvoker<TActual, TAssertionBuilder> And(..AssertionGroup<TActual, TAssertionBuilder> otherGroup) { }
+        public ..OrAssertionGroupInvoker<TActual, TAssertionBuilder> Or(..AssertionGroup<TActual, TAssertionBuilder> otherGroup) { }
     }
-    public static class IgnoringTypeGenericExtensions
+    public class UnknownAssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
     {
-        public static .<T> IgnoringType<T>(this .<T> assertion,  typeToIgnore) { }
+        public ..AndAssertionGroup<TActual, TAssertionBuilder> And(<TAssertionBuilder, .<TActual>> assert) { }
+        public ..OrAssertionGroup<TActual, TAssertionBuilder> Or(<TAssertionBuilder, .<TActual>> assert) { }
     }
-    public class MemberAssertion<TObject, TMember> : .<TMember>
+}
+namespace .
+{
+    public class BetweenAssertionBuilderWrapper<TActual> : .<TActual>
+        where TActual : <TActual>
     {
-        public MemberAssertion(<.<TObject>> objectProvider, .<<TObject, TMember>> memberSelector) { }
-        public .<TMember> EqualTo(TMember expected) { }
+        public ..BetweenAssertionBuilderWrapper<TActual> WithExclusiveBounds() { }
+        public ..BetweenAssertionBuilderWrapper<TActual> WithInclusiveBounds() { }
     }
-    public class NullAssertion<TActual> : .<TActual>
+    public class DateTimeEqualToAssertionBuilderWrapper : .<>
     {
-        public NullAssertion(<.<TActual>> actualValueProvider, bool shouldBeNull) { }
-        public NullAssertion(<TActual> actualValueProvider, bool shouldBeNull) { }
-        public NullAssertion(TActual actualValue, bool shouldBeNull) { }
-        protected override .<.> AssertAsync() { }
-        public new .<TActual> GetAwaiter() { }
+        public ..DateTimeEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
     }
-    public static class NullableStringAssertionBuilderExtensions
-    {
-        public static .<string?> DoesNotContain(this .<string?> builder, string substring) { }
-        public static .<string?> HasLength(this .<string?> builder, int expectedLength) { }
-        public static .<string?> IsEmpty(this .<string?> builder) { }
-        public static .<string?> IsNotEmpty(this .<string?> builder) { }
-    }
-    public static class NumericAssertionExtensions
-    {
-        public static .<double> IsInfinity(this .<double> builder) { }
-        public static .<double> IsNaN(this .<double> builder) { }
-        public static .<decimal> IsNegative(this .<decimal> builder) { }
-        public static .<double> IsNegative(this .<double> builder) { }
-        public static .<float> IsNegative(this .<float> builder) { }
-        public static .<int> IsNegative(this .<int> builder) { }
-        public static .<long> IsNegative(this .<long> builder) { }
-        public static .<short> IsNegative(this .<short> builder) { }
-        public static .<byte> IsPositive(this .<byte> builder) { }
-        public static .<decimal> IsPositive(this .<decimal> builder) { }
-        public static .<double> IsPositive(this .<double> builder) { }
-        public static .<float> IsPositive(this .<float> builder) { }
-        public static .<int> IsPositive(this .<int> builder) { }
-        public static .<long> IsPositive(this .<long> builder) { }
-        public static .<short> IsPositive(this .<short> builder) { }
-        public static .<int> IsZero(this .<int> builder) { }
-        public static .<decimal> Negative(this .<decimal> builder) { }
-        public static .<double> Negative(this .<double> builder) { }
-        public static .<float> Negative(this .<float> builder) { }
-        public static .<int> Negative(this .<int> builder) { }
-        public static .<long> Negative(this .<long> builder) { }
-        public static .<short> Negative(this .<short> builder) { }
-        public static .<byte> Positive(this .<byte> builder) { }
-        public static .<decimal> Positive(this .<decimal> builder) { }
-        public static .<double> Positive(this .<double> builder) { }
-        public static .<float> Positive(this .<float> builder) { }
-        public static .<int> Positive(this .<int> builder) { }
-        public static .<long> Positive(this .<long> builder) { }
-        public static .<short> Positive(this .<short> builder) { }
-        public static .<int> Zero(this .<int> builder) { }
-    }
-    public class NumericAssertion<T> : .<T>
-        where T :  struct, <T>
-    {
-        public NumericAssertion(<.<T>> actualValueProvider) { }
-        public NumericAssertion(<T> actualValueProvider) { }
-        protected override .<.> AssertAsync() { }
-        public .<T> GreaterThan(T other) { }
-        public .<T> GreaterThanOrEqualTo(T other) { }
-        public .<T> LessThan(T other) { }
-        public .<T> LessThanOrEqualTo(T other) { }
-        public .<T> Negative() { }
-        public .<T> NotZero() { }
-        public .<T> Positive() { }
-        public .<T> Zero() { }
-    }
-    public static class NumericRangeAssertionExtensions
-    {
-        public static .<decimal> IsBetween(this .<decimal> builder, decimal min, decimal max) { }
-        public static .<double> IsBetween(this .<double> builder, double min, double max) { }
-        public static .<int> IsBetween(this .<int> builder, int min, int max) { }
-        public static .<long> IsBetween(this .<long> builder, long min, long max) { }
-        public static .<decimal> IsNotBetween(this .<decimal> builder, decimal min, decimal max) { }
-        public static .<double> IsNotBetween(this .<double> builder, double min, double max) { }
-        public static .<int> IsNotBetween(this .<int> builder, int min, int max) { }
-        public static .<long> IsNotBetween(this .<long> builder, long min, long max) { }
-    }
-    public static class ObjectReferenceAssertionExtensions
-    {
-        public static .<TActual> IsNotSameReferenceAs<TActual>(this .<TActual> builder, object? expected) { }
-        public static .<TActual> IsSameReferenceAs<TActual>(this .<TActual> builder, object? expected) { }
-    }
-    public class ParseAssertion<T> : .<string?>
-    {
-        public ParseAssertion(<.<string?>> actualValueProvider, bool shouldBeParsable) { }
-        public ParseAssertion(<string?> actualValueProvider, bool shouldBeParsable) { }
-        public ParseAssertion(string? actualValue, bool shouldBeParsable) { }
-        protected override .<.> AssertAsync() { }
-        public .<T> WithFormatProvider( formatProvider) { }
-    }
-    public class PropertyMemberAssertion<TObject, TProperty> : .<TObject>
-    {
-        public PropertyMemberAssertion(<.<TObject>> actualValueProvider, <TObject, TProperty> propertySelector) { }
-        public PropertyMemberAssertion(<TObject> actualValueProvider, <TObject, TProperty> propertySelector) { }
-        protected override .<.> AssertAsync() { }
-        public .<TObject> EqualTo(TProperty expectedValue) { }
-        public .<TObject> IsEqualTo(TProperty expectedValue) { }
-    }
-    public class PropertySatisfiesAllAssertion<T, TProperty> : .<.<T>>
-    {
-        public PropertySatisfiesAllAssertion(<.<.<T>>> actualValueProvider, <T, TProperty> propertySelector, <.<TProperty>, .> assertionBuilder) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class PropertySatisfiesAllAsyncAssertion<T, TProperty> : .<.<T>>
-    {
-        public PropertySatisfiesAllAsyncAssertion(<.<.<T>>> actualValueProvider, <T, .<TProperty>> asyncPropertySelector, <.<TProperty>, .> assertionBuilder) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class PropertySatisfiesAssertion<TActual, TProperty> : .<TActual>
-    {
-        public PropertySatisfiesAssertion(<.<TActual>> actualValueProvider, <TActual, TProperty> propertySelector, <.<TProperty>, .> assertionBuilder) { }
-        public PropertySatisfiesAssertion(<TActual> actualValueProvider, <TActual, TProperty> propertySelector, <.<TProperty>, .> assertionBuilder) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class PropertySatisfiesAsyncAssertion<TActual, TProperty> : .<TActual>
-    {
-        public PropertySatisfiesAsyncAssertion(<.<TActual>> actualValueProvider, <TActual, .<TProperty>> asyncPropertySelector, <.<TProperty>, .> assertionBuilder) { }
-        public PropertySatisfiesAsyncAssertion(<TActual> actualValueProvider, <TActual, .<TProperty>> asyncPropertySelector, <.<TProperty>, .> assertionBuilder) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public static class RangeExtensions
-    {
-        public static .<TActual> WithExclusiveBounds<TActual>(this .<TActual> assertion)
-            where TActual : <TActual> { }
-        public static .<TActual> WithExclusiveBounds<TActual>(this .<TActual> assertion)
-            where TActual : <TActual> { }
-        public static .<TActual> WithInclusiveBounds<TActual>(this .<TActual> assertion)
-            where TActual : <TActual> { }
-        public static .<TActual> WithInclusiveBounds<TActual>(this .<TActual> assertion)
-            where TActual : <TActual> { }
+    public class DateTimeOffsetEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..DateTimeOffsetEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
     }
-    public static class ReferenceAssertionBuilderExtensions
+    public class EquivalentToAssertionBuilderWrapper<TActual, TExpected> : .<TActual>
     {
-        public static .<TActual> IsNotSameReferenceAs<TActual>(this .<TActual> builder, TActual? expected)
-            where TActual :  class { }
-        public static .<TActual> IsSameReferenceAs<TActual>(this .<TActual> builder, TActual? expected)
-            where TActual :  class { }
+        public ..EquivalentToAssertionBuilderWrapper<TActual, TExpected> IgnoringMember(string propertyName, [.("propertyName")] string doNotPopulateThis = "") { }
+        public ..EquivalentToAssertionBuilderWrapper<TActual, TExpected> IgnoringType( type, [.("type")] string doNotPopulateThis = "") { }
+        public ..EquivalentToAssertionBuilderWrapper<TActual, TExpected> IgnoringType<TType>() { }
+        public ..EquivalentToAssertionBuilderWrapper<TActual, TExpected> WithPartialEquivalency() { }
+    }
+    public class GenericEqualToAssertionBuilderWrapper<TActual> : .<TActual> { }
+    public class GenericNotEqualToAssertionBuilderWrapper<TActual> : .<TActual> { }
+    public class NotBetweenAssertionBuilderWrapper<TActual> : .<TActual>
+        where TActual : <TActual>
+    {
+        public ..NotBetweenAssertionBuilderWrapper<TActual> WithExclusiveBounds() { }
+        public ..NotBetweenAssertionBuilderWrapper<TActual> WithInclusiveBounds() { }
+    }
+    public class NotEquivalentToAssertionBuilderWrapper<TActual, TExpected> : .<TActual>
+    {
+        public ..NotEquivalentToAssertionBuilderWrapper<TActual, TExpected> IgnoringMember(string propertyName, [.("propertyName")] string doNotPopulateThis = "") { }
+        public ..NotEquivalentToAssertionBuilderWrapper<TActual, TExpected> IgnoringType( type, [.("type")] string doNotPopulateThis = "") { }
+        public ..NotEquivalentToAssertionBuilderWrapper<TActual, TExpected> IgnoringType<TType>() { }
+        public ..NotEquivalentToAssertionBuilderWrapper<TActual, TExpected> WithPartialEquivalency() { }
     }
-    public class ReferenceAssertion<TActual> : .<TActual>
+    public class NotNullAssertionBuilderWrapper<TActual> : .<TActual>
         where TActual :  class
     {
-        public ReferenceAssertion(<.<TActual>> actualValueProvider, TActual? expected, bool shouldBeSame) { }
-        public ReferenceAssertion(<TActual> actualValueProvider, TActual? expected, bool shouldBeSame) { }
-        public ReferenceAssertion(TActual actualValue, TActual? expected, bool shouldBeSame) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class SingleItemAssertion<TElement> : .<TElement>
-    {
-        public SingleItemAssertion(<.<.IEnumerable>> collectionProvider) { }
-    }
-    public static class StringAssertionBuilderExtensions
-    {
-        public static . Contains(this .<string> builder, string substring) { }
-        public static .<string> DoesNotContain(this .<string> builder, string substring) { }
-        public static .<string> DoesNotExist(this .<string> builder) { }
-        public static .<string> DoesNotMatch(this .<string> builder, . regex) { }
-        public static .<string> DoesNotMatch(this .<string> builder, string pattern) { }
-        public static . EndsWith(this .<string> builder, string suffix) { }
-        public static .<string> Exists(this .<string> builder) { }
-        public static .<int> HasCount(this .<string> builder) { }
-        public static .<string> HasFiles(this .<string> builder) { }
-        public static .<int> HasLength(this .<string> builder) { }
-        public static .<string> HasLength(this .<string> builder, int expectedLength) { }
-        public static .<string> HasNoSubdirectories(this .<string> builder) { }
-        public static .<string> IsDefault(this .<string> builder) { }
-        public static .<string> IsEmpty(this .<string> builder) { }
-        public static . IsEqualTo(this .<string> builder, string? expected) { }
-        public static . IsEqualTo(this .<string> builder, string? expected,  comparison) { }
-        public static .<string> IsNotDefault(this .<string> builder) { }
-        public static .<string> IsNotEmpty(this .<string> builder) { }
-        public static .<string> IsNotNullOrEmpty(this .<string> builder) { }
-        public static .<T> IsNotParsableInto<T>(this .<string> builder) { }
-        public static .<string> IsNullOrEmpty(this .<string> builder) { }
-        public static .<string> IsNullOrWhitespace(this .<string> builder) { }
-        public static .<T> IsParsableInto<T>(this .<string> builder) { }
-        public static .<string> Matches(this .<string> builder, . regex) { }
-        public static .<string> Matches(this .<string> builder, string pattern) { }
-        public static . StartsWith(this .<string> builder, string prefix) { }
-        public static .<T> WhenParsedInto<T>(this .<string> builder) { }
+        public new .<TActual> GetAwaiter() { }
     }
-    public static class StringAssertionExtensions
+    public class NotNullStructAssertionBuilderWrapper<TActual> : .<TActual>
+        where TActual :  struct
     {
-        public static . IsEqualToSimplified(this <string?> actualProvider, string? expected) { }
-        public static . IsEqualToSimplified(this .<string?> actualTask, string? expected) { }
-        public static . IsEqualToSimplified(this string? actual, string? expected) { }
+        public new .<TActual> GetAwaiter() { }
     }
-    public static class StringBuilderAssertionExtensions
+    public class ParseAssertionBuilderWrapper<TTarget> : .<string?>
     {
-        public static .<.StringBuilder> HasExcessCapacity(this .<.StringBuilder> builder) { }
-        public static .<.StringBuilder> HasNoExcessCapacity(this .<.StringBuilder> builder) { }
-        public static .<.StringBuilder> IsEmpty(this .<.StringBuilder> builder) { }
-        public static .<.StringBuilder> IsNotEmpty(this .<.StringBuilder> builder) { }
-    }
-    public class StringContainsAssertion : .<string?>
-    {
-        public StringContainsAssertion(<.<string?>> actualValueProvider, string substring) { }
-        public StringContainsAssertion(<string?> actualValueProvider, string substring) { }
-        public StringContainsAssertion(string? actualValue, string substring) { }
-        protected override .<.> AssertAsync() { }
-        public . IgnoringCase() { }
-        public . IgnoringWhitespace() { }
-        public . WithComparison( comparison) { }
-        public . WithTrimming() { }
-    }
-    public class StringEndsWithAssertion : .<string?>
-    {
-        public StringEndsWithAssertion(<.<string?>> actualValueProvider, string suffix) { }
-        public StringEndsWithAssertion(<string?> actualValueProvider, string suffix) { }
-        public StringEndsWithAssertion(string? actualValue, string suffix) { }
-        protected override .<.> AssertAsync() { }
-        public . IgnoringCase() { }
-        public . WithComparison( comparison) { }
-    }
-    public class StringEqualToAssertion : .<string?>
-    {
-        public StringEqualToAssertion(<.<string?>> actualValueProvider, string? expected) { }
-        public StringEqualToAssertion(<string?> actualValueProvider, string? expected) { }
-        public StringEqualToAssertion(string? actualValue, string? expected) { }
-        protected override .<.> AssertAsync() { }
-        public . IgnoringCase() { }
-        public . IgnoringWhitespace() { }
-        public . WithNullAndEmptyEquality() { }
-        public . WithStringComparison( comparison) { }
-        public . WithTrimming() { }
-    }
-    public class StringStartsWithAssertion : .<string?>
-    {
-        public StringStartsWithAssertion(<.<string?>> actualValueProvider, string prefix) { }
-        public StringStartsWithAssertion(<string?> actualValueProvider, string prefix) { }
-        public StringStartsWithAssertion(string? actualValue, string prefix) { }
-        protected override .<.> AssertAsync() { }
-        public . IgnoringCase() { }
-        public . WithComparison( comparison) { }
-    }
-    public class ThrowsNothingAssertion<TResult> : .<TResult>
-    {
-        public ThrowsNothingAssertion(<.<object?>> actualValueProvider) { }
-        protected override .<.> AssertAsync() { }
-        public new .<TResult> GetAwaiter() { }
-        public .<TResult> GetValueAsync() { }
-        public static .<TResult> op_Implicit(.<TResult> assertion) { }
-    }
-    public class TimeSpanAssertion : .<>
-    {
-        public TimeSpanAssertion(<.<>> actualValueProvider,  expected) { }
-        public TimeSpanAssertion(<> actualValueProvider,  expected) { }
-        public TimeSpanAssertion( actualValue,  expected) { }
-        protected override .<.> AssertAsync() { }
-        public . Within( tolerance) { }
-    }
-    public class TypeAssertion<TActual> : .<TActual>
-    {
-        public TypeAssertion(<.<TActual>> actualValueProvider,  expectedType, bool exact) { }
-        public TypeAssertion(<TActual> actualValueProvider,  expectedType, bool exact) { }
-        public TypeAssertion(TActual actualValue,  expectedType, bool exact) { }
-        protected override .<.> AssertAsync() { }
-    }
-    public class TypeOfAssertion<TExpected> : .<TExpected>
-        where TExpected :  class
-    {
-        public TypeOfAssertion(<.<object>> actualValueProvider) { }
-        public TypeOfAssertion(<object> actualValueProvider) { }
-        public new .<TExpected> And { get; }
-        protected override .<.> AssertAsync() { }
-        public new .<TExpected> GetAwaiter() { }
-        public .<TExpected> GetValueAsync() { }
-        public static .<TExpected> op_Implicit(.<TExpected> assertion) { }
-    }
-    public class ValueAssertionBuilder<TActual> : .
-    {
-        protected readonly <.<TActual>> _actualValueProvider;
-        protected readonly string? _expression;
-        public ValueAssertionBuilder(<.<TActual>> asyncValueProvider, string? expression = null) { }
-        public ValueAssertionBuilder(<TActual> valueProvider, string? expression = null) { }
-        public ValueAssertionBuilder(.<TActual> task, string? expression = null) { }
-        public ValueAssertionBuilder(.<TActual> valueTask, string? expression = null) { }
-        public ValueAssertionBuilder(TActual value, string? expression = null) { }
-        public .<TActual> And { get; }
-        public .<TActual> EqualTo(TActual expected) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void Equals(object? obj) { }
-        public override .<.AssertionData> GetAssertionData() { }
-        public override . GetAwaiter() { }
-        public .<TActual> GetTypedAwaiter() { }
-        public .<TActual> IsAssignableTo( expectedType) { }
-        public .<TActual> IsAssignableTo<TExpected>() { }
-        public .<TActual> IsEqualTo(TActual expected) { }
-        public .<TActual> IsEqualTo(object? expected) { }
-        public .<TActual> IsEqualTo(TActual expected, .<TActual> comparer) { }
-        public .<TActual> IsEqualTo(TActual expected, string because) { }
-        public .<TActual> IsEquatableOrEqualTo(TActual expected) { }
-        public .<TActual> IsEquivalentTo(.<object?> expected) { }
-        public .<TActual> IsEquivalentTo(.<object?> expected, . ordering) { }
-        public .<TActual> IsEquivalentTo(object? expected, <object, object, bool>? comparer = null) { }
-        public .<TActual> IsEquivalentTo<TElement>(.<TElement> expected, .<TElement> comparer) { }
-        public .<TActual> IsEquivalentTo<TExpected>(.<TExpected> expected, . ordering) { }
-        public .<TActual> IsIn(.<TActual> values) { }
-        public .<TActual> IsIn(params TActual[] values) { }
-        public .<TActual> IsNotAssignableTo( expectedType) { }
-        public .<TActual> IsNotAssignableTo<TExpected>() { }
-        public .<TActual> IsNotEqualTo(TActual expected) { }
-        public .<TActual> IsNotEqualTo(object? expected) { }
-        public .<TActual> IsNotEquivalentTo(.<object?> expected) { }
-        public .<TActual> IsNotEquivalentTo(.<object?> expected, . ordering) { }
-        public .<TActual> IsNotEquivalentTo(object? expected, <object, object, bool>? comparer = null) { }
-        public .<TActual> IsNotEquivalentTo<TExpected>(.<TExpected> expected, . ordering) { }
-        public .<TActual> IsNotIn(.<TActual> values) { }
-        public .<TActual> IsNotIn(params TActual[] values) { }
-        public .<TActual> IsNotNull() { }
-        public .<TActual> IsNotSameReferenceAs(TActual expected) { }
-        public .<TActual> IsNotSameReferenceAs(object? expected) { }
-        public .<TActual> IsNull() { }
-        public .<TActual> IsSameReferenceAs(TActual expected) { }
-        public .<TActual> IsSameReferenceAs(object? expected) { }
-        public .<TActual> IsTypeOf( expectedType) { }
-        public .<TExpected> IsTypeOf<TExpected>()
-            where TExpected :  class { }
-        public override . ProcessAssertionsAsync(.AssertionData data) { }
-        [("This is a base `object` method that should not be called.", true)]
-        public new void ReferenceEquals(object a, object b) { }
-        public .<TActual> Satisfies(<TActual, bool> predicate, string? failureMessage = null) { }
-        public .<TActual> Satisfies<TConverted>(<TActual, TConverted> converter, <.<TConverted>, .<TConverted>> assertionBuilder) { }
-        public .<TActual, TProperty> Satisfies<TProperty>(.<<TActual, .<TProperty>>> asyncPropertySelector, <.<TProperty>, .> assertionBuilder) { }
-        public .<TActual, TProperty> Satisfies<TProperty>(.<<TActual, TProperty>> propertySelector, <.<TProperty>, .> assertionBuilder) { }
+        public .<string?> WithFormatProvider(? formatProvider) { }
     }
-    public static class WeakReferenceAssertionExtensions
+    public class SingleItemAssertionBuilderWrapper<TActual, TInner> : .<TActual>
+        where TActual : .<TInner>
     {
-        public static .<> IsAlive(this .<> builder) { }
-        public static .<> IsDead(this .<> builder) { }
+        public new .<TInner> GetAwaiter() { }
     }
-    public class WhenParsedAssertion<T> : .<T>
+    public class StringContainsAssertionBuilderWrapper : .<string>
     {
-        public WhenParsedAssertion(<.<string?>> stringValueProvider, ? formatProvider = null) { }
+        public ..StringContainsAssertionBuilderWrapper IgnoringWhitespace() { }
+        public ..StringContainsAssertionBuilderWrapper WithTrimming() { }
     }
-}
-namespace .
-{
-    public class ChainedAssertion
+    public class StringEqualToAssertionBuilderWrapper : .<string>
     {
-        public ChainedAssertion(. assertion, . chainType = 0) { }
-        public . Assertion { get; }
-        public . ChainType { get; }
+        public ..StringEqualToAssertionBuilderWrapper IgnoringWhitespace() { }
+        public ..StringEqualToAssertionBuilderWrapper WithNullAndEmptyEquality() { }
+        public ..StringEqualToAssertionBuilderWrapper WithTrimming() { }
+    }
+    public class TimeSpanEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..TimeSpanEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
     }
 }
 namespace .
 {
-    public interface IAssertionChain
+    public class CompleteWithinAssertCondition<TActual> : .<TActual>
+    {
+        public CompleteWithinAssertCondition( timeSpan) { }
+        public override ? WaitFor { get; }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class DelegateExtensions
     {
-        void AddAndAssertion(. assertion);
-        void AddAssertion(. assertion, . chainType = 0);
-        void AddOrAssertion(. assertion);
-        .<..ChainedAssertion> GetAssertions();
-        .<.> GetBaseAssertions();
-        .? GetLastAssertion();
+        public static . CompletesWithin(this ..IDelegateSource delegateSource,  timeSpan, [.("timeSpan")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> CompletesWithin<TActual>(this ..IValueDelegateSource<TActual> delegateSource,  timeSpan, [.("timeSpan")] string? doNotPopulateThisValue = null) { }
     }
 }
-namespace .Attributes
+namespace ..Conditions
 {
-    [(.Method)]
-    public sealed class AssertionAttribute : 
+    public class EnumDoesNotHaveFlagAssertCondition<TEnum> : .<TEnum>
+        where TEnum : 
     {
-        public AssertionAttribute(string expectation, string? but = null) { }
-        public string? But { get; }
-        public string Expectation { get; }
+        public EnumDoesNotHaveFlagAssertCondition(TEnum expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    [(.Class, AllowMultiple=true)]
-    public class CreateAssertionAttribute : 
+    public class EnumDoesNotHaveSameNameAsCondition<TEnum, TExpected> : .<TEnum>
+        where TEnum : 
+        where TExpected : 
     {
-        public CreateAssertionAttribute( targetType, string methodName) { }
-        public CreateAssertionAttribute( targetType,  containingType, string methodName) { }
-        public ? ContainingType { get; }
-        public string? CustomName { get; set; }
-        public string MethodName { get; }
-        public bool NegateLogic { get; set; }
+        public EnumDoesNotHaveSameNameAsCondition(TExpected expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumDoesNotHaveSameValueAsCondition<TEnum, TExpected> : .<TEnum>
+        where TEnum : 
+        where TExpected : 
+    {
+        public EnumDoesNotHaveSameValueAsCondition(TExpected expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumHasFlagAssertCondition<TEnum> : .<TEnum>
+        where TEnum : 
+    {
+        public EnumHasFlagAssertCondition(TEnum expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumHasSameNameAsCondition<TEnum, TExpected> : .<TEnum>
+        where TEnum : 
+        where TExpected : 
+    {
+        public EnumHasSameNameAsCondition(TExpected expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumHasSameValueAsCondition<TEnum, TExpected> : .<TEnum>
+        where TEnum : 
+        where TExpected : 
+    {
+        public EnumHasSameValueAsCondition(TExpected expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumIsDefinedAssertCondition<TEnum> : .<TEnum>
+        where TEnum :  struct, 
+    {
+        public EnumIsDefinedAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumIsNotDefinedAssertCondition<TEnum> : .<TEnum>
+        where TEnum :  struct, 
+    {
+        public EnumIsNotDefinedAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+}
+namespace .
+{
+    public static class EnumHasExtensions
+    {
+        public static .<TEnum> DoesNotHaveFlag<TEnum>(this ..IValueSource<TEnum> valueSource, TEnum expected, [.("expected")] string? doNotPopulateThisValue1 = null)
+            where TEnum :  { }
+        public static .<TEnum> DoesNotHaveSameNameAs<TEnum, TExpected>(this ..IValueSource<TEnum> valueSource, TExpected expected, [.("expected")] string? doNotPopulateThisValue1 = null)
+            where TEnum : 
+            where TExpected :  { }
+        public static .<TEnum> DoesNotHaveSameValueAs<TEnum, TExpected>(this ..IValueSource<TEnum> valueSource, TExpected expected, [.("expected")] string? doNotPopulateThisValue1 = null)
+            where TEnum : 
+            where TExpected :  { }
+        public static .<TEnum> HasFlag<TEnum>(this ..IValueSource<TEnum> valueSource, TEnum expected, [.("expected")] string? doNotPopulateThisValue1 = null)
+            where TEnum :  { }
+        public static .<TEnum> HasSameNameAs<TEnum, TExpected>(this ..IValueSource<TEnum> valueSource, TExpected expected, [.("expected")] string? doNotPopulateThisValue1 = null)
+            where TEnum : 
+            where TExpected :  { }
+        public static .<TEnum> HasSameValueAs<TEnum, TExpected>(this ..IValueSource<TEnum> valueSource, TExpected expected, [.("expected")] string? doNotPopulateThisValue1 = null)
+            where TEnum : 
+            where TExpected :  { }
+    }
+}
+namespace ..Conditions
+{
+    public class AssignableFromExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public AssignableFromExpectedValueAssertCondition( expectedType) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class AssignableToExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public AssignableToExpectedValueAssertCondition( expectedType) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ConvertExceptionToValueAssertCondition<TException> : .<object?>
+        where TException : 
+    {
+        public ConvertExceptionToValueAssertCondition() { }
+        public TException ConvertedExceptionValue { get; }
+        protected override string GetExpectation() { }
+        protected override sealed .<.> GetResult(object? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DefaultExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public DefaultExpectedValueAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DelegateConversionAssertionCondition<TToType> : .<TToType>
+        where TToType : 
+    {
+        public DelegateConversionAssertionCondition(..IDelegateSource source, .<object?> assertCondition) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TToType? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EqualsExpectedValueAssertCondition<TActual> : .<TActual, TActual>
+    {
+        public EqualsExpectedValueAssertCondition(TActual expected) { }
+        public EqualsExpectedValueAssertCondition(TActual expected, .<TActual> equalityComparer) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TActual? expectedValue) { }
+    }
+    public class EquivalentToExpectedValueAssertCondition<TActual, TExpected> : .<TActual, TExpected>
+    {
+        public EquivalentToExpectedValueAssertCondition(TExpected expected, string? expectedExpression) { }
+        public . EquivalencyKind { get; set; }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TExpected? expectedValue) { }
+        public void IgnoringMember(string fieldName) { }
+        public void IgnoringType( type) { }
+    }
+    public class NotAssignableFromExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public NotAssignableFromExpectedValueAssertCondition( expectedType) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class NotAssignableToExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public NotAssignableToExpectedValueAssertCondition( expectedType) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class NotDefaultExpectedValueAssertCondition<TActual> : .<TActual, TActual>
+    {
+        public NotDefaultExpectedValueAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TActual? expectedValue) { }
+    }
+    public class NotEqualsExpectedValueAssertCondition<TActual> : .<TActual, TActual>
+    {
+        public NotEqualsExpectedValueAssertCondition(TActual expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TActual? expectedValue) { }
+    }
+    public class NotEquivalentToExpectedValueAssertCondition<TActual, TExpected> : .<TActual, TExpected>
+    {
+        public NotEquivalentToExpectedValueAssertCondition(TExpected expected, string? expectedExpression) { }
+        public . EquivalencyKind { get; set; }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TExpected? expectedValue) { }
+        public void IgnoringMember(string fieldName) { }
+        public void IgnoringType( type) { }
+    }
+    public class NotSameReferenceExpectedValueAssertCondition<TActual, TExpected> : .<TActual, TExpected>
+    {
+        public NotSameReferenceExpectedValueAssertCondition(TExpected expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TExpected? expectedValue) { }
+    }
+    public class NotTypeOfExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public NotTypeOfExpectedValueAssertCondition( expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class SameReferenceExpectedValueAssertCondition<TActual, TExpected> : .<TActual, TExpected>
+    {
+        public SameReferenceExpectedValueAssertCondition(TExpected expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TExpected? expectedValue) { }
+    }
+    public class TypeOfExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public TypeOfExpectedValueAssertCondition( expectedType) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ValueConversionAssertionCondition<TFromType, TToType> : .<TToType>
+    {
+        public ValueConversionAssertionCondition(..ISource source, .<TFromType, TToType> convertToAssertCondition) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TToType? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+}
+namespace ..Conditions
+{
+    public class ParseConversionAssertCondition<TTarget> : .<string?, TTarget>
+    {
+        public ParseConversionAssertCondition(? formatProvider = null) { }
+        public override .<<., TTarget?>> ConvertValue(string? value) { }
+        protected override string GetExpectation() { }
+    }
+    public class StringContainsExpectedValueAssertCondition : .<string, string>
+    {
+        public StringContainsExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, string? expectedValue) { }
+    }
+    public class StringIsNotParsableCondition<TTarget> : .<string?, ?>
+    {
+        public StringIsNotParsableCondition(? formatProvider = null) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? formatProvider) { }
+    }
+    public class StringIsParsableCondition<TTarget> : .<string?, ?>
+    {
+        public StringIsParsableCondition(? formatProvider = null) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? formatProvider) { }
+    }
+}
+namespace .
+{
+    public static class StringParsingExtensions
+    {
+        public static ..ParseAssertionBuilderWrapper<TTarget> IsNotParsableInto<TTarget>(this ..IValueSource<string> valueSource, [.("valueSource")] string? doNotPopulateThisValue = null) { }
+        public static ..ParseAssertionBuilderWrapper<TTarget> IsParsableInto<TTarget>(this ..IValueSource<string> valueSource, [.("valueSource")] string? doNotPopulateThisValue = null) { }
+        public static .<TTarget> WhenParsedInto<TTarget>(this ..IValueSource<string> valueSource, ? formatProvider = null, [.("valueSource")] string? doNotPopulateThisValue = null) { }
+    }
+}
+namespace .Attributes
+{
+    [(.Class, AllowMultiple=true)]
+    public class CreateAssertionAttribute : 
+    {
+        public CreateAssertionAttribute( targetType, string methodName) { }
+        public CreateAssertionAttribute( targetType,  containingType, string methodName) { }
+        public ? ContainingType { get; }
+        public string? CustomName { get; set; }
+        public string MethodName { get; }
+        public bool NegateLogic { get; set; }
         public bool RequiresGenericTypeParameter { get; set; }
         public  TargetType { get; }
         public bool TreatAsInstance { get; set; }
@@ -1449,336 +1206,1791 @@ namespace .Exceptions
 }
 namespace .Extensions
 {
-    public static class AssertionBuilderCollectionExtensions
-    {
-        public static .<TCollection> Contains<TCollection, TElement>(this .<TCollection> builder, TElement item)
-            where TCollection : .<TElement> { }
-        public static .<.<TElement>> ContainsOnly<TElement>(this .<.<TElement>> builder, <TElement, bool> predicate) { }
-        public static .<TCollection> ContainsOnly<TCollection, TElement>(this .<TCollection> builder, <TElement, bool> predicate)
-            where TCollection : .<TElement> { }
-        public static .<.<TElement>> DoesNotContain<TElement>(this .<.<TElement>> builder, <TElement, bool> predicate) { }
-        public static .<TCollection> DoesNotContain<TCollection, TElement>(this .<TCollection> builder, <TElement, bool> predicate)
-            where TCollection : .<TElement> { }
-        public static .<TCollection> DoesNotContain<TCollection, TElement>(this .<TCollection> builder, TElement item)
-            where TCollection : .<TElement> { }
-        public static .<int> HasCount<TElement>(this .<.<TElement>> builder) { }
-        public static .<.<TElement>> HasCount<TElement>(this .<.<TElement>> builder, int expectedCount) { }
-        public static .<TCollection> HasCount<TCollection, TElement>(this .<TCollection> builder, int expectedCount)
-            where TCollection : .<TElement> { }
-        public static .<.<TElement>> HasDistinctItems<TElement>(this .<.<TElement>> builder) { }
-        public static .<TCollection> HasDistinctItems<TCollection, TElement>(this .<TCollection> builder)
-            where TCollection : .<TElement> { }
-        public static .<.<TElement>> HasSingleItem<TElement>(this .<.<TElement>> builder) { }
-        public static .<TCollection> HasSingleItem<TCollection, TElement>(this .<TCollection> builder)
-            where TCollection : .<TElement> { }
-        public static .<.<TElement>> IsEmpty<TElement>(this .<.<TElement>> builder) { }
-        public static .<TCollection> IsEmpty<TCollection, TElement>(this .<TCollection> builder)
-            where TCollection : .<TElement> { }
-        public static .<.<TElement>> IsNotEmpty<TElement>(this .<.<TElement>> builder) { }
-        public static .<TCollection> IsNotEmpty<TCollection, TElement>(this .<TCollection> builder)
-            where TCollection : .<TElement> { }
-    }
-    public static class BecauseExtensions
-    {
-        public static TAssertionBuilder Because<TAssertionBuilder>(this TAssertionBuilder assertionBuilder, string reason, [.("reason")] string? reasonExpression = null)
-            where TAssertionBuilder : . { }
+    public class AggregateExceptionExceptionAssertionExtensionsHasMultipleInnerExceptionsWithAggregateExceptionAssertCondition : .<>
+    {
+        public AggregateExceptionExceptionAssertionExtensionsHasMultipleInnerExceptionsWithAggregateExceptionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class BooleanAssertionExtensions
-    {
-        public static . IsFalse(this .<bool> builder) { }
-        public static . IsFalse(this .<bool?> builder) { }
-        public static . IsFalse(this .<bool> builder) { }
-        public static . IsFalse(this .<bool?> builder) { }
-        public static . IsTrue(this .<bool> builder) { }
-        public static . IsTrue(this .<bool?> builder) { }
-        public static . IsTrue(this .<bool> builder) { }
-        public static . IsTrue(this .<bool?> builder) { }
-    }
-    public static class CollectionAssertionExtensions
-    {
-        public static .<TCollection> Contains<TCollection, TElement>(this .<TCollection> builder, TElement item)
-            where TCollection : .<TElement> { }
-        public static .<TCollection> Contains<TCollection, TElement>(this .<TCollection> builder, TElement item)
-            where TCollection : .<TElement> { }
-        public static .<.<T>> ContainsOnly<T>(this .<.<T>> builder, <T, bool> predicate) { }
-        public static .<TCollection> DoesNotContain<TCollection, TElement>(this .<TCollection> builder, TElement item)
-            where TCollection : .<TElement> { }
-        public static .<TCollection> DoesNotContain<TCollection, TElement>(this .<TCollection> builder, TElement item)
-            where TCollection : .<TElement> { }
-        public static .<TCollection> HasCount<TCollection>(this .<TCollection> builder, int expectedCount)
-            where TCollection : .IEnumerable { }
-        public static .<.<T>> HasSingleItem<T>(this .<.<T>> builder) { }
-        public static .<.<T>> HasSingleItem<T>(this .<.<T>> builder) { }
-        public static .<TCollection> IsEmpty<TCollection>(this .<TCollection> builder)
-            where TCollection : .IEnumerable { }
-        public static .<TCollection> IsEmpty<TCollection>(this .<TCollection> builder)
-            where TCollection : .IEnumerable { }
-        public static .<TCollection> IsEquivalentTo<TCollection, TElement>(this .<TCollection> builder, .<TElement> expected)
-            where TCollection : .<TElement>
-            where TElement :  notnull { }
-        public static .<TCollection> IsNotEmpty<TCollection>(this .<TCollection> builder)
-            where TCollection : .IEnumerable { }
-        public static .<TCollection> IsNotEmpty<TCollection>(this .<TCollection> builder)
-            where TCollection : .IEnumerable { }
-        public static .<TCollection> IsNotEquivalentTo<TCollection, TElement>(this .<TCollection> builder, .<TElement> expected)
-            where TCollection : .<TElement>
-            where TElement :  notnull { }
-    }
-    public static class ComparableAssertionExtensions
-    {
-        public static .<T> GreaterThanOrEqualTo<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> GreaterThanOrEqualTo<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsBetween<T>(this .<T> builder, T min, T max)
-            where T : <T> { }
-        public static .<T> IsBetween<T>(this .<T> builder, T min, T max)
-            where T : <T> { }
-        public static .<T> IsGreaterThan<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsGreaterThan<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsGreaterThanOrEqualTo<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsGreaterThanOrEqualTo<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsLessThan<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsLessThan<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsLessThanOrEqualTo<T>(this .<T> builder, T value)
-            where T : <T> { }
-        public static .<T> IsLessThanOrEqualTo<T>(this .<T> builder, T value)
-            where T : <T> { }
-    }
-    public static class CustomAssertionExtensions
-    {
-        public static .<TActual> RegisterAssertion<TActual>(this ..IValueSource<TActual> valueSource, .<TActual> condition, string[]? expressions = null) { }
-        public static .<TActual> RegisterAssertion<TActual>(this .<TActual> builder, .<TActual> condition, string[]? expressions = null) { }
-        public static .<TToType> RegisterConversionAssertion<TActual, TToType>(this ..IValueSource<TActual> valueSource, .<TActual, TToType> condition, string[]? expressions = null) { }
-        public static .<TToType> RegisterConversionAssertion<TActual, TToType>(this .<TActual> builder, .<TActual, TToType> condition, string[]? expressions = null) { }
-        public static .<TToType> RegisterConversionAssertion<TActual, TToType>(this .<TActual> builder, .<TActual, TToType> condition, string[]? expressions = null) { }
-    }
-    public static class DelegateAssertionExtensions
-    {
-        public static .<> CompletesWithin(this .<> builder,  timeout) { }
-        public static .<<.>> CompletesWithin(this .<<.>> builder,  timeout) { }
-        public static .<T> CompletesWithin<T>(this .<T> builder,  timeout) { }
-        public static .<> DoesNotCompleteWithin(this .<> builder,  timeout) { }
-        public static .<<.>> DoesNotCompleteWithin(this .<<.>> builder,  timeout) { }
-        public static .<T> DoesNotCompleteWithin<T>(this .<T> builder,  timeout) { }
-    }
-    public static class DictionaryAssertionExtensions
-    {
-        public static .<TDictionary> ContainsKey<TDictionary>(this .<TDictionary> builder, object key)
-            where TDictionary :  class { }
-        public static .<.<string, TValue>> ContainsKey<TValue>(this .<.<string, TValue>> builder, string key, .<string> comparer) { }
-        public static .<.<TKey, TValue>> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> builder, TValue value)
-            where TKey :  notnull { }
-        public static .<TDictionary> DoesNotContainKey<TDictionary>(this .<TDictionary> builder, object key)
-            where TDictionary :  class { }
-        public static .<.<TKey, TValue>> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<.<TKey, TValue>> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> builder, TKey key)
-            where TKey :  notnull { }
-        public static .<int> HasCount<TKey, TValue>(this .<.<TKey, TValue>> builder)
-            where TKey :  notnull { }
-        public static .<int> HasCount<TKey, TValue>(this .<.<TKey, TValue>> builder) { }
+    public class AssemblyAssemblyAssertionExtensionsIsDebugBuildWithAssemblyAssertCondition : .<.Assembly>
+    {
+        public AssemblyAssemblyAssertionExtensionsIsDebugBuildWithAssemblyAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class EnumAssertionExtensions
+    public class AssemblyAssemblyAssertionExtensionsIsSignedWithAssemblyAssertCondition : .<.Assembly>
     {
-        public static .<TEnum> DoesNotHaveFlag<TEnum>(this .<TEnum> builder, TEnum flag)
-            where TEnum :  { }
-        public static .<TEnum> DoesNotHaveFlag<TEnum>(this .<TEnum> builder, TEnum flag)
-            where TEnum :  { }
-        public static .<TEnum> DoesNotHaveSameNameAs<TEnum>(this .<TEnum> builder,  other)
-            where TEnum :  { }
-        public static .<TEnum> DoesNotHaveSameNameAs<TEnum>(this .<TEnum> builder,  other)
-            where TEnum :  { }
-        public static .<TEnum> DoesNotHaveSameValueAs<TEnum>(this .<TEnum> builder,  other)
-            where TEnum :  { }
-        public static .<TEnum> HasFlag<TEnum>(this .<TEnum> builder, TEnum flag)
-            where TEnum :  { }
-        public static .<TEnum> HasFlag<TEnum>(this .<TEnum> builder, TEnum flag)
-            where TEnum :  { }
-        public static .<TEnum> HasSameNameAs<TEnum>(this .<TEnum> builder,  other)
-            where TEnum :  { }
-        public static .<TEnum> HasSameNameAs<TEnum>(this .<TEnum> builder,  other)
-            where TEnum :  { }
-        public static .<TEnum> HasSameValueAs<TEnum>(this .<TEnum> builder,  other)
-            where TEnum :  { }
-        public static .<TEnum> IsDefined<TEnum>(this .<TEnum> builder)
-            where TEnum :  { }
-        public static .<TEnum> IsDefined<TEnum>(this .<TEnum> builder)
-            where TEnum :  { }
-        public static .<TEnum> IsNotDefined<TEnum>(this .<TEnum> builder)
-            where TEnum :  { }
-        public static .<TEnum> IsNotDefined<TEnum>(this .<TEnum> builder)
-            where TEnum :  { }
+        public AssemblyAssemblyAssertionExtensionsIsSignedWithAssemblyAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.Assembly>("GlobalAssemblyCache")]
+    [.<.Assembly>("GlobalAssemblyCache", CustomName="IsNotInGAC", NegateLogic=true)]
+    [.<.Assembly>("IsDynamic")]
+    [.<.Assembly>("IsDynamic", CustomName="IsNotDynamic", NegateLogic=true)]
+    [.<.Assembly>("IsFullyTrusted")]
+    [.<.Assembly>("IsFullyTrusted", CustomName="IsNotFullyTrusted", NegateLogic=true)]
+    [.<.Assembly>(typeof(.), "IsDebugBuild")]
+    [.<.Assembly>(typeof(.), "IsDebugBuild", CustomName="IsReleaseBuild", NegateLogic=true)]
+    [.<.Assembly>(typeof(.), "IsSigned")]
+    [.<.Assembly>(typeof(.), "IsSigned", CustomName="IsNotSigned", NegateLogic=true)]
+    public static class AssemblyAssertionExtensions
+    {
+        public static .<.Assembly> GlobalAssemblyCache(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsDebugBuild(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsDynamic(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsFullyTrusted(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsNotDynamic(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsNotFullyTrusted(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsNotInGAC(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsNotSigned(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsReleaseBuild(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsSigned(this ..IValueSource<.Assembly> valueSource) { }
+    }
+    public class AssemblyGlobalAssemblyCacheAssertCondition : .<.Assembly>
+    {
+        public AssemblyGlobalAssemblyCacheAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class ExceptionAssertionExtensions
+    public class AssemblyIsDynamicAssertCondition : .<.Assembly>
     {
-        public static .<TException> HasMessageContaining<TException>(this .<TException> builder, string substring)
-            where TException :  { }
-        public static .<TException> HasMessageContaining<TException>(this .<TException> builder, string substring)
-            where TException :  { }
-        public static .<TException> HasMessageEndingWith<TException>(this .<TException> builder, string suffix)
-            where TException :  { }
-        public static .<TException> HasMessageEndingWith<TException>(this .<TException> assertion, string suffix)
-            where TException :  { }
-        public static .<TException> HasMessageEndingWith<TException>(this .<TException> builder, string suffix)
-            where TException :  { }
-        public static .<TException> HasMessageEqualTo<TException>(this .<TException> builder, string expectedMessage)
-            where TException :  { }
-        public static .<TException> HasMessageMatching<TException>(this .<TException> assertion, string pattern)
-            where TException :  { }
-        public static .<TException> HasMessageStartingWith<TException>(this .<TException> builder, string prefix)
-            where TException :  { }
-        public static .<TException> HasMessageStartingWith<TException>(this .<TException> assertion, string prefix)
-            where TException :  { }
-        public static .<TException> HasMessageStartingWith<TException>(this .<TException> builder, string prefix)
-            where TException :  { }
+        public AssemblyIsDynamicAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class AssemblyIsFullyTrustedAssertCondition : .<.Assembly>
+    {
+        public AssemblyIsFullyTrustedAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class BooleanIsExtensions
+    {
+        public static .<bool> IsEqualTo(this ..IValueSource<bool> valueSource, bool expected) { }
+        public static .<bool?> IsEqualTo(this ..IValueSource<bool?> valueSource, bool expected) { }
+        public static .<bool?> IsEqualTo(this ..IValueSource<bool?> valueSource, bool? expected) { }
+        public static .<bool> IsFalse(this ..IValueSource<bool> valueSource) { }
+        public static .<bool?> IsFalse(this ..IValueSource<bool?> valueSource) { }
+        public static .<bool> IsTrue(this ..IValueSource<bool> valueSource) { }
+        public static .<bool?> IsTrue(this ..IValueSource<bool?> valueSource) { }
+    }
+    public static class BooleanIsNotExtensions
+    {
+        public static .<bool> IsNotEqualTo(this ..IValueSource<bool> valueSource, bool expected) { }
+        public static .<bool?> IsNotEqualTo(this ..IValueSource<bool?> valueSource, bool expected) { }
+        public static .<bool?> IsNotEqualTo(this ..IValueSource<bool?> valueSource, bool? expected) { }
+        public static .<bool> IsNotFalse(this ..IValueSource<bool> valueSource) { }
+        public static .<bool?> IsNotFalse(this ..IValueSource<bool?> valueSource) { }
+        public static .<bool> IsNotTrue(this ..IValueSource<bool> valueSource) { }
+        public static .<bool?> IsNotTrue(this ..IValueSource<bool?> valueSource) { }
+    }
+    [.<.CancellationToken>("CanBeCanceled")]
+    [.<.CancellationToken>("CanBeCanceled", CustomName="CannotBeCanceled", NegateLogic=true)]
+    [.<.CancellationToken>("IsCancellationRequested")]
+    [.<.CancellationToken>("IsCancellationRequested", CustomName="IsNotCancellationRequested", NegateLogic=true)]
+    [.<.CancellationToken>(typeof(.), "IsNone")]
+    [.<.CancellationToken>(typeof(.), "IsNone", CustomName="IsNotNone", NegateLogic=true)]
+    public static class CancellationTokenAssertionExtensions
+    {
+        public static .<.CancellationToken> CanBeCanceled(this ..IValueSource<.CancellationToken> valueSource) { }
+        public static .<.CancellationToken> CannotBeCanceled(this ..IValueSource<.CancellationToken> valueSource) { }
+        public static .<.CancellationToken> IsCancellationRequested(this ..IValueSource<.CancellationToken> valueSource) { }
+        public static .<.CancellationToken> IsNone(this ..IValueSource<.CancellationToken> valueSource) { }
+        public static .<.CancellationToken> IsNotCancellationRequested(this ..IValueSource<.CancellationToken> valueSource) { }
+        public static .<.CancellationToken> IsNotNone(this ..IValueSource<.CancellationToken> valueSource) { }
+    }
+    public class CancellationTokenCanBeCanceledAssertCondition : .<.CancellationToken>
+    {
+        public CancellationTokenCanBeCanceledAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CancellationToken actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class GenericAssertionExtensions
-    {
-        public static .<T> DoesNotHaveMember<T>(this .<T> builder, string memberName) { }
-        public static .<T> DoesNotHaveMember<T>(this .<T> builder, string memberName) { }
-        public static .<T> HasMember<T>(this .<T> builder, string memberName) { }
-        public static .<T> HasMember<T>(this .<T> builder, string memberName) { }
-        public static .<T, TMember> HasMember<T, TMember>(this .<T> builder, .<<T, TMember>> memberSelector) { }
-        public static .<T> IsDefault<T>(this .<T> builder) { }
-        public static .<T> IsDefault<T>(this .<T> builder) { }
-        public static .<T> IsNotDefault<T>(this .<T> builder) { }
-        public static .<T> IsNotDefault<T>(this .<T> builder) { }
-    }
-    public static class NumericAssertionExtensions
-    {
-        public static .<int> IsGreaterThan(this .<int> builder, int value) { }
-        public static .<byte> IsGreaterThan(this .<byte> builder, byte value) { }
-        public static .<decimal> IsGreaterThan(this .<decimal> builder, decimal value) { }
-        public static .<double> IsGreaterThan(this .<double> builder, double value) { }
-        public static .<float> IsGreaterThan(this .<float> builder, float value) { }
-        public static .<int> IsGreaterThan(this .<int> builder, int value) { }
-        public static .<long> IsGreaterThan(this .<long> builder, long value) { }
-        public static .<short> IsGreaterThan(this .<short> builder, short value) { }
-        public static .<int> IsGreaterThanOrEqualTo(this .<int> builder, int value) { }
-        public static .<byte> IsGreaterThanOrEqualTo(this .<byte> builder, byte value) { }
-        public static .<decimal> IsGreaterThanOrEqualTo(this .<decimal> builder, decimal value) { }
-        public static .<double> IsGreaterThanOrEqualTo(this .<double> builder, double value) { }
-        public static .<float> IsGreaterThanOrEqualTo(this .<float> builder, float value) { }
-        public static .<int> IsGreaterThanOrEqualTo(this .<int> builder, int value) { }
-        public static .<long> IsGreaterThanOrEqualTo(this .<long> builder, long value) { }
-        public static .<short> IsGreaterThanOrEqualTo(this .<short> builder, short value) { }
-        public static .<int> IsLessThan(this .<int> builder, int value) { }
-        public static .<byte> IsLessThan(this .<byte> builder, byte value) { }
-        public static .<decimal> IsLessThan(this .<decimal> builder, decimal value) { }
-        public static .<double> IsLessThan(this .<double> builder, double value) { }
-        public static .<float> IsLessThan(this .<float> builder, float value) { }
-        public static .<int> IsLessThan(this .<int> builder, int value) { }
-        public static .<long> IsLessThan(this .<long> builder, long value) { }
-        public static .<short> IsLessThan(this .<short> builder, short value) { }
-        public static .<int> IsLessThanOrEqualTo(this .<int> builder, int value) { }
-        public static .<byte> IsLessThanOrEqualTo(this .<byte> builder, byte value) { }
-        public static .<decimal> IsLessThanOrEqualTo(this .<decimal> builder, decimal value) { }
-        public static .<double> IsLessThanOrEqualTo(this .<double> builder, double value) { }
-        public static .<float> IsLessThanOrEqualTo(this .<float> builder, float value) { }
-        public static .<int> IsLessThanOrEqualTo(this .<int> builder, int value) { }
-        public static .<long> IsLessThanOrEqualTo(this .<long> builder, long value) { }
-        public static .<short> IsLessThanOrEqualTo(this .<short> builder, short value) { }
-        public static .<int> IsNegative(this .<int> builder) { }
-        public static .<decimal> IsNegative(this .<decimal> builder) { }
-        public static .<double> IsNegative(this .<double> builder) { }
-        public static .<float> IsNegative(this .<float> builder) { }
-        public static .<int> IsNegative(this .<int> builder) { }
-        public static .<long> IsNegative(this .<long> builder) { }
-        public static .<short> IsNegative(this .<short> builder) { }
-        public static .<int> IsPositive(this .<int> builder) { }
-        public static .<byte> IsPositive(this .<byte> builder) { }
-        public static .<decimal> IsPositive(this .<decimal> builder) { }
-        public static .<double> IsPositive(this .<double> builder) { }
-        public static .<float> IsPositive(this .<float> builder) { }
-        public static .<int> IsPositive(this .<int> builder) { }
-        public static .<long> IsPositive(this .<long> builder) { }
-        public static .<short> IsPositive(this .<short> builder) { }
+    public class CancellationTokenCancellationTokenAssertionExtensionsIsNoneWithCancellationTokenAssertCondition : .<.CancellationToken>
+    {
+        public CancellationTokenCancellationTokenAssertionExtensionsIsNoneWithCancellationTokenAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CancellationToken actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class StringAssertionExtensions
+    public class CancellationTokenIsCancellationRequestedAssertCondition : .<.CancellationToken>
     {
-        public static . Contains(this .<string> builder, string substring) { }
-        public static . Contains(this .<string> builder, string substring) { }
-        public static .<string> DoesNotContain(this .<string> builder, string substring) { }
-        public static .<string> DoesNotContain(this .<string> builder, string substring) { }
-        public static .<string> DoesNotMatch(this .<string> builder, . regex) { }
-        public static .<string> DoesNotMatch(this .<string> builder, string pattern) { }
-        public static .<string> DoesNotMatch(this .<string> builder, . regex) { }
-        public static .<string> DoesNotMatch(this .<string> builder, string pattern) { }
-        public static . EndsWith(this .<string> builder, string suffix) { }
-        public static . EndsWith(this .<string> builder, string suffix) { }
-        public static .<int> HasCount(this .<string> builder) { }
-        public static .<int> HasLength(this .<string> builder) { }
-        public static .<int> HasLength(this .<string> builder) { }
-        public static .<string> HasLength(this .<string> builder, int expectedLength) { }
-        public static .<string> HasLength(this .<string> builder, int expectedLength) { }
-        public static .<string> IsEmpty(this .<string> builder) { }
-        public static .<string> IsEmpty(this .<string> builder) { }
-        public static .<string> IsEqualTo(this .<string> builder, string expected,  comparisonType) { }
-        public static .<string> IsEqualTo(this .<string> builder, string expected,  comparisonType) { }
-        public static .<string> IsNotEmpty(this .<string> builder) { }
-        public static .<string> IsNotEmpty(this .<string> builder) { }
-        public static .<string> IsNotEqualTo(this .<string> builder, string expected,  comparisonType) { }
-        public static .<string> IsNotEqualTo(this .<string> builder, string expected,  comparisonType) { }
-        public static .<string> IsNotNullOrEmpty(this .<string> builder) { }
-        public static .<string> IsNotNullOrWhiteSpace(this .<string> builder) { }
-        public static .<string> IsNotNullOrWhitespace(this .<string> builder) { }
-        public static .<string> IsNotNullOrWhitespace(this .<string> builder) { }
-        public static .<string> IsNullOrEmpty(this .<string> builder) { }
-        public static .<string> IsNullOrWhiteSpace(this .<string> builder) { }
-        public static .<string> IsNullOrWhitespace(this .<string> builder) { }
-        public static .<string> IsNullOrWhitespace(this .<string> builder) { }
-        public static .<string> Matches(this .<string> builder, . regex) { }
-        public static .<string> Matches(this .<string> builder, string pattern) { }
-        public static .<string> Matches(this .<string> builder, . regex) { }
-        public static .<string> Matches(this .<string> builder, string pattern) { }
-        public static . StartsWith(this .<string> builder, string prefix) { }
-        public static . StartsWith(this .<string> builder, string prefix) { }
+        public CancellationTokenIsCancellationRequestedAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CancellationToken actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<char>("IsControl")]
+    [.<char>("IsControl", CustomName="IsNotControl", NegateLogic=true)]
+    [.<char>("IsDigit")]
+    [.<char>("IsDigit", CustomName="IsNotDigit", NegateLogic=true)]
+    [.<char>("IsHighSurrogate")]
+    [.<char>("IsHighSurrogate", CustomName="IsNotHighSurrogate", NegateLogic=true)]
+    [.<char>("IsLetter")]
+    [.<char>("IsLetter", CustomName="IsNotLetter", NegateLogic=true)]
+    [.<char>("IsLetterOrDigit")]
+    [.<char>("IsLetterOrDigit", CustomName="IsNotLetterOrDigit", NegateLogic=true)]
+    [.<char>("IsLowSurrogate")]
+    [.<char>("IsLowSurrogate", CustomName="IsNotLowSurrogate", NegateLogic=true)]
+    [.<char>("IsLower")]
+    [.<char>("IsLower", CustomName="IsNotLower", NegateLogic=true)]
+    [.<char>("IsNumber")]
+    [.<char>("IsNumber", CustomName="IsNotNumber", NegateLogic=true)]
+    [.<char>("IsPunctuation")]
+    [.<char>("IsPunctuation", CustomName="IsNotPunctuation", NegateLogic=true)]
+    [.<char>("IsSeparator")]
+    [.<char>("IsSeparator", CustomName="IsNotSeparator", NegateLogic=true)]
+    [.<char>("IsSurrogate")]
+    [.<char>("IsSurrogate", CustomName="IsNotSurrogate", NegateLogic=true)]
+    [.<char>("IsSymbol")]
+    [.<char>("IsSymbol", CustomName="IsNotSymbol", NegateLogic=true)]
+    [.<char>("IsUpper")]
+    [.<char>("IsUpper", CustomName="IsNotUpper", NegateLogic=true)]
+    [.<char>("IsWhiteSpace")]
+    [.<char>("IsWhiteSpace", CustomName="IsNotWhiteSpace", NegateLogic=true)]
+    public static class CharAssertionExtensions
+    {
+        public static .<char> IsControl(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsDigit(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsHighSurrogate(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsLetter(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsLetterOrDigit(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsLowSurrogate(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsLower(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotControl(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotDigit(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotHighSurrogate(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotLetter(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotLetterOrDigit(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotLowSurrogate(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotLower(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotNumber(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotPunctuation(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotSeparator(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotSurrogate(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotSymbol(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotUpper(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNotWhiteSpace(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsNumber(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsPunctuation(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsSeparator(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsSurrogate(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsSymbol(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsUpper(this ..IValueSource<char> valueSource) { }
+        public static .<char> IsWhiteSpace(this ..IValueSource<char> valueSource) { }
+    }
+    public class CharIsControlWithCharAssertCondition : .<char>
+    {
+        public CharIsControlWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class StringExtensions
+    public class CharIsDigitWithCharAssertCondition : .<char>
     {
-        public static string GetStringOr(this string? value, string defaultValue) { }
-        public static string GetStringOrEmpty(this string? value) { }
-        public static string PrependAOrAn(this string value) { }
-        public static string ReplaceNewLines(this string value) { }
-        public static string ShowNewLines(this string value) { }
-        public static string TruncateWithEllipsis(this string value, int maxLength) { }
+        public CharIsDigitWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
-    public static class StringParseExtensions
+    public static class CharIsExtensions
     {
-        public static .<T> IsNotParsableInto<T>(this .<string> builder) { }
-        public static .<T> IsNotParsableInto<T>(this .<string> builder) { }
-        public static .<T> IsParsableInto<T>(this .<string> builder) { }
-        public static .<T> IsParsableInto<T>(this .<string> builder) { }
-        public static .<string> IsParsableInto<T>(this .<string> builder, ? formatProvider) { }
-        public static .<T> WhenParsedInto<T>(this .<string> builder) { }
-        public static .<T> WhenParsedInto<T>(this .<string> builder) { }
+        public static .<char> IsEqualTo(this ..IValueSource<char> valueSource, char expected) { }
+        public static .<char?> IsEqualTo(this ..IValueSource<char?> valueSource, char expected) { }
+        public static .<char?> IsEqualTo(this ..IValueSource<char?> valueSource, char? expected) { }
     }
-    public static class TimeSpanExtensions
+    public class CharIsHighSurrogateWithCharAssertCondition : .<char>
     {
-        public static  Days(this int days) { }
-        public static  Hours(this int hours) { }
-        public static  Milliseconds(this int milliseconds) { }
-        public static  Minutes(this int minutes) { }
-        public static  Seconds(this int seconds) { }
+        public CharIsHighSurrogateWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsLetterOrDigitWithCharAssertCondition : .<char>
+    {
+        public CharIsLetterOrDigitWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsLetterWithCharAssertCondition : .<char>
+    {
+        public CharIsLetterWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsLowSurrogateWithCharAssertCondition : .<char>
+    {
+        public CharIsLowSurrogateWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsLowerWithCharAssertCondition : .<char>
+    {
+        public CharIsLowerWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class CharIsNotExtensions
+    {
+        public static .<char> IsNotEqualTo(this ..IValueSource<char> valueSource, char expected) { }
+        public static .<char?> IsNotEqualTo(this ..IValueSource<char?> valueSource, char expected) { }
+        public static .<char?> IsNotEqualTo(this ..IValueSource<char?> valueSource, char? expected) { }
+    }
+    public class CharIsNumberWithCharAssertCondition : .<char>
+    {
+        public CharIsNumberWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsPunctuationWithCharAssertCondition : .<char>
+    {
+        public CharIsPunctuationWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsSeparatorWithCharAssertCondition : .<char>
+    {
+        public CharIsSeparatorWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsSurrogateWithCharAssertCondition : .<char>
+    {
+        public CharIsSurrogateWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsSymbolWithCharAssertCondition : .<char>
+    {
+        public CharIsSymbolWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsUpperWithCharAssertCondition : .<char>
+    {
+        public CharIsUpperWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharIsWhiteSpaceWithCharAssertCondition : .<char>
+    {
+        public CharIsWhiteSpaceWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CharUriIsHexDigitWithCharAssertCondition : .<char>
+    {
+        public CharUriIsHexDigitWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class CollectionsIsExtensions
+    {
+        public static .<.<TInner>> IsEmpty<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<TActual> IsEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .<TInner> { }
+        public static .<TActual> IsEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, .<TInner> comparer, [.("expected")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null)
+            where TActual : .<TInner> { }
+        public static .<TActual> IsEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null, [.("collectionOrdering")] string doNotPopulateThisValue2 = null)
+            where TActual : .<TInner> { }
+        public static .<TActual> IsEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, .<TInner> comparer, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null, [.("collectionOrdering")] string doNotPopulateThisValue2 = null)
+            where TActual : .<TInner> { }
+        public static .<.<TInner>> IsInDescendingOrder<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsInDescendingOrder<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> comparer) { }
+        public static .<.<TInner>> IsInOrder<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsInOrder<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> comparer) { }
+        public static .<.<TInner>> IsOrderedBy<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, [.("comparisonItemSelector")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsOrderedBy<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, .<TComparisonItem> comparer, [.("comparisonItemSelector")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null) { }
+        public static .<.<TInner>> IsOrderedByDescending<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, [.("comparisonItemSelector")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsOrderedByDescending<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, .<TComparisonItem> comparer, [.("comparisonItemSelector")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null) { }
+    }
+    public static class CollectionsIsNotExtensions
+    {
+        public static .<.<TInner>> IsNotEmpty<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<TActual> IsNotEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .<TInner> { }
+        public static .<TActual> IsNotEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, .<TInner> comparer, [.("expected")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null)
+            where TActual : .<TInner> { }
+        public static .<TActual> IsNotEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null, [.("collectionOrdering")] string doNotPopulateThisValue2 = null)
+            where TActual : .<TInner> { }
+        public static .<TActual> IsNotEquivalentTo<TActual, TInner>(this ..IValueSource<TActual> valueSource, .<TInner> expected, .<TInner> comparer, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null, [.("collectionOrdering")] string doNotPopulateThisValue2 = null)
+            where TActual : .<TInner> { }
+    }
+    public static class ComparableIsExtensions
+    {
+        public static ..BetweenAssertionBuilderWrapper<TActual> IsBetween<TActual>(this ..IValueSource<TActual> valueSource, TActual lowerBound, TActual upperBound, [.("lowerBound")] string doNotPopulateThisValue1 = null, [.("upperBound")] string doNotPopulateThisValue2 = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsGreaterThan<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsGreaterThanOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsLessThan<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsLessThanOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+    }
+    public static class ComparableIsNotExtensions
+    {
+        public static ..NotBetweenAssertionBuilderWrapper<TActual> IsNotBetween<TActual>(this ..IValueSource<TActual> valueSource, TActual lowerBound, TActual upperBound, [.("lowerBound")] string doNotPopulateThisValue1 = null, [.("upperBound")] string doNotPopulateThisValue2 = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsNotGreaterThan<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsNotGreaterThanOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsNotLessThan<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+        public static .<TActual> IsNotLessThanOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : <TActual> { }
+    }
+    [.<.CultureInfo>("IsNeutralCulture")]
+    [.<.CultureInfo>("IsNeutralCulture", CustomName="IsNotNeutralCulture", NegateLogic=true)]
+    [.<.CultureInfo>("IsReadOnly")]
+    [.<.CultureInfo>("IsReadOnly", CustomName="IsNotReadOnly", NegateLogic=true)]
+    [.<.CultureInfo>(typeof(.), "IsEnglish")]
+    [.<.CultureInfo>(typeof(.), "IsEnglish", CustomName="IsNotEnglish", NegateLogic=true)]
+    [.<.CultureInfo>(typeof(.), "IsInvariant")]
+    [.<.CultureInfo>(typeof(.), "IsInvariant", CustomName="IsNotInvariant", NegateLogic=true)]
+    [.<.CultureInfo>(typeof(.), "IsRightToLeft")]
+    [.<.CultureInfo>(typeof(.), "IsRightToLeft", CustomName="IsLeftToRight", NegateLogic=true)]
+    public static class CultureInfoAssertionExtensions
+    {
+        public static .<.CultureInfo> IsEnglish(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsInvariant(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsLeftToRight(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsNeutralCulture(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsNotEnglish(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsNotInvariant(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsNotNeutralCulture(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsNotReadOnly(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsReadOnly(this ..IValueSource<.CultureInfo> valueSource) { }
+        public static .<.CultureInfo> IsRightToLeft(this ..IValueSource<.CultureInfo> valueSource) { }
+    }
+    public class CultureInfoCultureInfoAssertionExtensionsIsEnglishWithCultureInfoAssertCondition : .<.CultureInfo>
+    {
+        public CultureInfoCultureInfoAssertionExtensionsIsEnglishWithCultureInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CultureInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CultureInfoCultureInfoAssertionExtensionsIsInvariantWithCultureInfoAssertCondition : .<.CultureInfo>
+    {
+        public CultureInfoCultureInfoAssertionExtensionsIsInvariantWithCultureInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CultureInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CultureInfoCultureInfoAssertionExtensionsIsRightToLeftWithCultureInfoAssertCondition : .<.CultureInfo>
+    {
+        public CultureInfoCultureInfoAssertionExtensionsIsRightToLeftWithCultureInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CultureInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CultureInfoIsNeutralCultureAssertCondition : .<.CultureInfo>
+    {
+        public CultureInfoIsNeutralCultureAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CultureInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CultureInfoIsReadOnlyAssertCondition : .<.CultureInfo>
+    {
+        public CultureInfoIsReadOnlyAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CultureInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<>(typeof(), "IsDaylightSavingTime")]
+    [.<>(typeof(), "IsDaylightSavingTime", CustomName="IsNotDaylightSavingTime", NegateLogic=true)]
+    [.<>(typeof(.), "IsLeapYear")]
+    [.<>(typeof(.), "IsLeapYear", CustomName="IsNotLeapYear", NegateLogic=true)]
+    [.<>(typeof(.), "IsToday")]
+    [.<>(typeof(.), "IsToday", CustomName="IsNotToday", NegateLogic=true)]
+    [.<>(typeof(.), "IsUtc")]
+    [.<>(typeof(.), "IsUtc", CustomName="IsNotUtc", NegateLogic=true)]
+    [.<>(typeof(.), "IsWeekend")]
+    [.<>(typeof(.), "IsWeekend", CustomName="IsWeekday", NegateLogic=true)]
+    [.<>(typeof(), "EqualsExact")]
+    public static class DateTimeAssertionExtensions
+    {
+        public static .<> EqualsExact(this ..IValueSource<> valueSource,  other, [.("other")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsDaylightSavingTime(this ..IValueSource<> valueSource) { }
+        public static .<> IsLeapYear(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotDaylightSavingTime(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotLeapYear(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotToday(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotUtc(this ..IValueSource<> valueSource) { }
+        public static .<> IsToday(this ..IValueSource<> valueSource) { }
+        public static .<> IsUtc(this ..IValueSource<> valueSource) { }
+        public static .<> IsWeekday(this ..IValueSource<> valueSource) { }
+        public static .<> IsWeekend(this ..IValueSource<> valueSource) { }
+    }
+    public class DateTimeDateTimeAssertionExtensionsIsLeapYearWithDateTimeAssertCondition : .<>
+    {
+        public DateTimeDateTimeAssertionExtensionsIsLeapYearWithDateTimeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DateTimeDateTimeAssertionExtensionsIsTodayWithDateTimeAssertCondition : .<>
+    {
+        public DateTimeDateTimeAssertionExtensionsIsTodayWithDateTimeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DateTimeDateTimeAssertionExtensionsIsUtcWithDateTimeAssertCondition : .<>
+    {
+        public DateTimeDateTimeAssertionExtensionsIsUtcWithDateTimeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DateTimeDateTimeAssertionExtensionsIsWeekendWithDateTimeAssertCondition : .<>
+    {
+        public DateTimeDateTimeAssertionExtensionsIsWeekendWithDateTimeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DateTimeIsDaylightSavingTimeAssertCondition : .<>
+    {
+        public DateTimeIsDaylightSavingTimeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class DateTimeIsExtensions
+    {
+        public static .<> IsAfter(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<> IsAfterOrEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<> IsBefore(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<> IsBeforeOrEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static ..DateTimeEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+    }
+    public class DateTimeOffsetEqualsExactWithDateTimeOffsetAssertCondition : .<>
+    {
+        public DateTimeOffsetEqualsExactWithDateTimeOffsetAssertCondition( other, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class DateTimeOffsetIsExtensions
+    {
+        public static .<> IsAfter(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<> IsAfterOrEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<> IsBefore(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<> IsBeforeOrEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static ..DateTimeOffsetEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+    }
+    [.<>(typeof(.), "IsFriday")]
+    [.<>(typeof(.), "IsFriday", CustomName="IsNotFriday", NegateLogic=true)]
+    [.<>(typeof(.), "IsMonday")]
+    [.<>(typeof(.), "IsMonday", CustomName="IsNotMonday", NegateLogic=true)]
+    [.<>(typeof(.), "IsWeekend")]
+    [.<>(typeof(.), "IsWeekend", CustomName="IsWeekday", NegateLogic=true)]
+    public static class DayOfWeekAssertionExtensions
+    {
+        public static .<> IsFriday(this ..IValueSource<> valueSource) { }
+        public static .<> IsMonday(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotFriday(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotMonday(this ..IValueSource<> valueSource) { }
+        public static .<> IsWeekday(this ..IValueSource<> valueSource) { }
+        public static .<> IsWeekend(this ..IValueSource<> valueSource) { }
+    }
+    public class DayOfWeekDayOfWeekAssertionExtensionsIsFridayWithDayOfWeekAssertCondition : .<>
+    {
+        public DayOfWeekDayOfWeekAssertionExtensionsIsFridayWithDayOfWeekAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DayOfWeekDayOfWeekAssertionExtensionsIsMondayWithDayOfWeekAssertCondition : .<>
+    {
+        public DayOfWeekDayOfWeekAssertionExtensionsIsMondayWithDayOfWeekAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DayOfWeekDayOfWeekAssertionExtensionsIsWeekendWithDayOfWeekAssertCondition : .<>
+    {
+        public DayOfWeekDayOfWeekAssertionExtensionsIsWeekendWithDayOfWeekAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.DirectoryInfo>("Exists")]
+    [.<.DirectoryInfo>("Exists", CustomName="DoesNotExist", NegateLogic=true)]
+    [.<.DirectoryInfo>(typeof(.), "HasFiles")]
+    [.<.DirectoryInfo>(typeof(.), "HasFiles", CustomName="HasNoFiles", NegateLogic=true)]
+    [.<.DirectoryInfo>(typeof(.), "HasSubdirectories")]
+    [.<.DirectoryInfo>(typeof(.), "HasSubdirectories", CustomName="HasNoSubdirectories", NegateLogic=true)]
+    [.<.DirectoryInfo>(typeof(.), "IsEmpty")]
+    [.<.DirectoryInfo>(typeof(.), "IsEmpty", CustomName="IsNotEmpty", NegateLogic=true)]
+    [.<.DirectoryInfo>(typeof(.), "IsHidden")]
+    [.<.DirectoryInfo>(typeof(.), "IsHidden", CustomName="IsNotHidden", NegateLogic=true)]
+    [.<.DirectoryInfo>(typeof(.), "IsReadOnly")]
+    [.<.DirectoryInfo>(typeof(.), "IsReadOnly", CustomName="IsNotReadOnly", NegateLogic=true)]
+    [.<.DirectoryInfo>(typeof(.), "IsSystem")]
+    [.<.DirectoryInfo>(typeof(.), "IsSystem", CustomName="IsNotSystem", NegateLogic=true)]
+    public static class DirectoryInfoAssertionExtensions
+    {
+        public static .<.DirectoryInfo> DoesNotExist(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> Exists(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> HasFiles(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> HasNoFiles(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> HasNoSubdirectories(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> HasSubdirectories(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsEmpty(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsHidden(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsNotEmpty(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsNotHidden(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsNotReadOnly(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsNotSystem(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsReadOnly(this ..IValueSource<.DirectoryInfo> valueSource) { }
+        public static .<.DirectoryInfo> IsSystem(this ..IValueSource<.DirectoryInfo> valueSource) { }
+    }
+    public class DirectoryInfoDirectoryInfoAssertionExtensionsHasFilesWithDirectoryInfoAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoDirectoryInfoAssertionExtensionsHasFilesWithDirectoryInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DirectoryInfoDirectoryInfoAssertionExtensionsHasSubdirectoriesWithDirectoryInfoAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoDirectoryInfoAssertionExtensionsHasSubdirectoriesWithDirectoryInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DirectoryInfoDirectoryInfoAssertionExtensionsIsEmptyWithDirectoryInfoAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoDirectoryInfoAssertionExtensionsIsEmptyWithDirectoryInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DirectoryInfoDirectoryInfoAssertionExtensionsIsHiddenWithDirectoryInfoAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoDirectoryInfoAssertionExtensionsIsHiddenWithDirectoryInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DirectoryInfoDirectoryInfoAssertionExtensionsIsReadOnlyWithDirectoryInfoAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoDirectoryInfoAssertionExtensionsIsReadOnlyWithDirectoryInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DirectoryInfoDirectoryInfoAssertionExtensionsIsSystemWithDirectoryInfoAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoDirectoryInfoAssertionExtensionsIsSystemWithDirectoryInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class DirectoryInfoExistsAssertCondition : .<.DirectoryInfo>
+    {
+        public DirectoryInfoExistsAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.DirectoryInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class DoesExtensions
+    {
+        public static ..StringContainsAssertionBuilderWrapper Contains(this ..IValueSource<string> valueSource, string expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static ..StringContainsAssertionBuilderWrapper Contains(this ..IValueSource<string> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null) { }
+        public static .<.<TInner>, ..EnumerableContainsExpectedFuncAssertCondition<.<TInner>, TInner>, TInner> Contains<TInner>(this ..IValueSource<.<TInner>> valueSource, <TInner, bool> matcher, [.("matcher")] string doNotPopulateThisValue = null) { }
+        public static .<TActual> Contains<TActual, TInner>(this ..IValueSource<TActual> valueSource, TInner expected, .<TInner> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .<TInner> { }
+        public static .<.<TKey, TValue>> ContainsKey<TKey, TValue>(this ..IValueSource<.<TKey, TValue>> valueSource, TKey expected, .<TKey> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<TDictionary> ContainsKey<TDictionary, TKey>(this ..IValueSource<TDictionary> valueSource, TKey expected, .<TKey> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null)
+            where TDictionary : .IDictionary { }
+        public static .<.<TInner>> ContainsOnly<TInner>(this ..IValueSource<.<TInner>> valueSource, <TInner, bool> matcher, [.("matcher")] string doNotPopulateThisValue = null) { }
+        public static .<TDictionary> ContainsValue<TDictionary, TValue>(this ..IValueSource<TDictionary> valueSource, TValue expected, .<TValue> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null)
+            where TDictionary : .IDictionary { }
+        public static .<string> Matches(this ..IValueSource<string> valueSource, . regex, [.("regex")] string expression = "") { }
+        public static .<string> Matches(this ..IValueSource<string> valueSource, string regex, [.("regex")] string expression = "") { }
+    }
+    public static class DoesNotExtensions
+    {
+        public static .<.<TInner>> DoesNotContain<TInner>(this ..IValueSource<.<TInner>> valueSource, <TInner, bool> matcher, [.("matcher")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> DoesNotContain<TActual, TInner>(this ..IValueSource<TActual> valueSource, TInner expected, .<TInner?>? equalityComparer = null, [.("expected")] string? doNotPopulateThisValue = null)
+            where TActual : .<TInner> { }
+        public static .<.<TKey, TValue>> DoesNotContainKey<TKey, TValue>(this ..IValueSource<.<TKey, TValue>> valueSource, TKey expected, .<TKey> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<TDictionary> DoesNotContainKey<TDictionary, TKey>(this ..IValueSource<TDictionary> valueSource, TKey expected, .<TKey> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null)
+            where TDictionary : .IDictionary { }
+        public static .<.<TKey, TValue>> DoesNotContainValue<TKey, TValue>(this ..IValueSource<.<TKey, TValue>> valueSource, TValue expected, .<TValue> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<TDictionary> DoesNotContainValue<TDictionary, TValue>(this ..IValueSource<TDictionary> valueSource, TValue expected, .<TValue> equalityComparer = null, [.("expected")] string doNotPopulateThisValue = null)
+            where TDictionary : .IDictionary { }
+        public static .<string> DoesNotMatch(this ..IValueSource<string> valueSource, . regex, [.("regex")] string expression = "") { }
+        public static .<string> DoesNotMatch(this ..IValueSource<string> valueSource, string regex, [.("regex")] string expression = "") { }
+    }
+    [.<.Encoding>("IsSingleByte")]
+    [.<.Encoding>("IsSingleByte", CustomName="IsNotSingleByte", NegateLogic=true)]
+    [.<.Encoding>(typeof(.), "IsASCII")]
+    [.<.Encoding>(typeof(.), "IsASCII", CustomName="IsNotASCII", NegateLogic=true)]
+    [.<.Encoding>(typeof(.), "IsBigEndianUnicode")]
+    [.<.Encoding>(typeof(.), "IsBigEndianUnicode", CustomName="IsNotBigEndianUnicode", NegateLogic=true)]
+    [.<.Encoding>(typeof(.), "IsUTF32")]
+    [.<.Encoding>(typeof(.), "IsUTF32", CustomName="IsNotUTF32", NegateLogic=true)]
+    [.<.Encoding>(typeof(.), "IsUTF8")]
+    [.<.Encoding>(typeof(.), "IsUTF8", CustomName="IsNotUTF8", NegateLogic=true)]
+    [.<.Encoding>(typeof(.), "IsUnicode")]
+    [.<.Encoding>(typeof(.), "IsUnicode", CustomName="IsNotUnicode", NegateLogic=true)]
+    public static class EncodingAssertionExtensions
+    {
+        public static .<.Encoding> IsASCII(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsBigEndianUnicode(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsNotASCII(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsNotBigEndianUnicode(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsNotSingleByte(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsNotUTF32(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsNotUTF8(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsNotUnicode(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsSingleByte(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsUTF32(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsUTF8(this ..IValueSource<.Encoding> valueSource) { }
+        public static .<.Encoding> IsUnicode(this ..IValueSource<.Encoding> valueSource) { }
+    }
+    public class EncodingEncodingAssertionExtensionsIsASCIIWithEncodingAssertCondition : .<.Encoding>
+    {
+        public EncodingEncodingAssertionExtensionsIsASCIIWithEncodingAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Encoding? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EncodingEncodingAssertionExtensionsIsBigEndianUnicodeWithEncodingAssertCondition : .<.Encoding>
+    {
+        public EncodingEncodingAssertionExtensionsIsBigEndianUnicodeWithEncodingAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Encoding? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EncodingEncodingAssertionExtensionsIsUTF32WithEncodingAssertCondition : .<.Encoding>
+    {
+        public EncodingEncodingAssertionExtensionsIsUTF32WithEncodingAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Encoding? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EncodingEncodingAssertionExtensionsIsUTF8WithEncodingAssertCondition : .<.Encoding>
+    {
+        public EncodingEncodingAssertionExtensionsIsUTF8WithEncodingAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Encoding? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EncodingEncodingAssertionExtensionsIsUnicodeWithEncodingAssertCondition : .<.Encoding>
+    {
+        public EncodingEncodingAssertionExtensionsIsUnicodeWithEncodingAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Encoding? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EncodingIsSingleByteAssertCondition : .<.Encoding>
+    {
+        public EncodingIsSingleByteAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Encoding? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<>("HasFlag")]
+    [.<>("HasFlag", CustomName="DoesNotHaveFlag", NegateLogic=true)]
+    public static class EnumAssertionExtensions
+    {
+        public static .<> DoesNotHaveFlag(this ..IValueSource<> valueSource,  flag, [.("flag")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> HasFlag(this ..IValueSource<> valueSource,  flag, [.("flag")] string? doNotPopulateThisValue1 = null) { }
+        public static .<TEnum> IsDefined<TEnum>(this ..IValueSource<TEnum> valueSource)
+            where TEnum :  struct,  { }
+        public static .<TEnum> IsNotDefined<TEnum>(this ..IValueSource<TEnum> valueSource)
+            where TEnum :  struct,  { }
+    }
+    public class EnumHasFlagWithEnumAssertCondition : .<>
+    {
+        public EnumHasFlagWithEnumAssertCondition( flag, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumerableCount<TActual, TInner>
+        where TActual : .<TInner>
+    {
+        public EnumerableCount(..IValueSource<TActual> valueSource) { }
+        public .<TActual> Empty { get; }
+        public .<TActual> EqualTo(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual> EqualToOne() { }
+        public .<TActual> EqualToZero() { }
+        public .<TActual> GreaterThan(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual> GreaterThanOrEqualTo(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual> LessThan(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual> LessThanOrEqualTo(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual> Negative() { }
+        public .<TActual> Positive() { }
+    }
+    [.<>(typeof(.), "HasMultipleInnerExceptions")]
+    [.<>(typeof(.), "HasMultipleInnerExceptions", CustomName="HasSingleInnerException", NegateLogic=true)]
+    [.<>(typeof(.), "HasData")]
+    [.<>(typeof(.), "HasData", CustomName="HasNoData", NegateLogic=true)]
+    [.<>(typeof(.), "HasHelpLink")]
+    [.<>(typeof(.), "HasHelpLink", CustomName="HasNoHelpLink", NegateLogic=true)]
+    [.<>(typeof(.), "HasInnerException")]
+    [.<>(typeof(.), "HasInnerException", CustomName="HasNoInnerException", NegateLogic=true)]
+    [.<>(typeof(.), "HasStackTrace")]
+    [.<>(typeof(.), "HasStackTrace", CustomName="HasNoStackTrace", NegateLogic=true)]
+    public static class ExceptionAssertionExtensions
+    {
+        public static .<> HasData(this ..IValueSource<> valueSource) { }
+        public static .<> HasHelpLink(this ..IValueSource<> valueSource) { }
+        public static .<> HasInnerException(this ..IValueSource<> valueSource) { }
+        public static .<> HasMultipleInnerExceptions(this ..IValueSource<> valueSource) { }
+        public static .<> HasNoData(this ..IValueSource<> valueSource) { }
+        public static .<> HasNoHelpLink(this ..IValueSource<> valueSource) { }
+        public static .<> HasNoInnerException(this ..IValueSource<> valueSource) { }
+        public static .<> HasNoStackTrace(this ..IValueSource<> valueSource) { }
+        public static .<> HasSingleInnerException(this ..IValueSource<> valueSource) { }
+        public static .<> HasStackTrace(this ..IValueSource<> valueSource) { }
+    }
+    public class ExceptionExceptionAssertionExtensionsHasDataWithExceptionAssertCondition : .<>
+    {
+        public ExceptionExceptionAssertionExtensionsHasDataWithExceptionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ExceptionExceptionAssertionExtensionsHasHelpLinkWithExceptionAssertCondition : .<>
+    {
+        public ExceptionExceptionAssertionExtensionsHasHelpLinkWithExceptionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ExceptionExceptionAssertionExtensionsHasInnerExceptionWithExceptionAssertCondition : .<>
+    {
+        public ExceptionExceptionAssertionExtensionsHasInnerExceptionWithExceptionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ExceptionExceptionAssertionExtensionsHasStackTraceWithExceptionAssertCondition : .<>
+    {
+        public ExceptionExceptionAssertionExtensionsHasStackTraceWithExceptionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.FileInfo>("Exists")]
+    [.<.FileInfo>("Exists", CustomName="DoesNotExist", NegateLogic=true)]
+    [.<.FileInfo>("IsReadOnly")]
+    [.<.FileInfo>("IsReadOnly", CustomName="IsNotReadOnly", NegateLogic=true)]
+    [.<.FileInfo>(typeof(.), "IsCompressed")]
+    [.<.FileInfo>(typeof(.), "IsCompressed", CustomName="IsNotCompressed", NegateLogic=true)]
+    [.<.FileInfo>(typeof(.), "IsEmpty")]
+    [.<.FileInfo>(typeof(.), "IsEmpty", CustomName="IsNotEmpty", NegateLogic=true)]
+    [.<.FileInfo>(typeof(.), "IsEncrypted")]
+    [.<.FileInfo>(typeof(.), "IsEncrypted", CustomName="IsNotEncrypted", NegateLogic=true)]
+    [.<.FileInfo>(typeof(.), "IsExecutable")]
+    [.<.FileInfo>(typeof(.), "IsExecutable", CustomName="IsNotExecutable", NegateLogic=true)]
+    [.<.FileInfo>(typeof(.), "IsHidden")]
+    [.<.FileInfo>(typeof(.), "IsHidden", CustomName="IsNotHidden", NegateLogic=true)]
+    [.<.FileInfo>(typeof(.), "IsSystem")]
+    [.<.FileInfo>(typeof(.), "IsSystem", CustomName="IsNotSystem", NegateLogic=true)]
+    public static class FileInfoAssertionExtensions
+    {
+        public static .<.FileInfo> DoesNotExist(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> Exists(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsCompressed(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsEmpty(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsEncrypted(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsExecutable(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsHidden(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotCompressed(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotEmpty(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotEncrypted(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotExecutable(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotHidden(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotReadOnly(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsNotSystem(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsReadOnly(this ..IValueSource<.FileInfo> valueSource) { }
+        public static .<.FileInfo> IsSystem(this ..IValueSource<.FileInfo> valueSource) { }
+    }
+    public class FileInfoExistsAssertCondition : .<.FileInfo>
+    {
+        public FileInfoExistsAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoFileInfoAssertionExtensionsIsCompressedWithFileInfoAssertCondition : .<.FileInfo>
+    {
+        public FileInfoFileInfoAssertionExtensionsIsCompressedWithFileInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoFileInfoAssertionExtensionsIsEmptyWithFileInfoAssertCondition : .<.FileInfo>
+    {
+        public FileInfoFileInfoAssertionExtensionsIsEmptyWithFileInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoFileInfoAssertionExtensionsIsEncryptedWithFileInfoAssertCondition : .<.FileInfo>
+    {
+        public FileInfoFileInfoAssertionExtensionsIsEncryptedWithFileInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoFileInfoAssertionExtensionsIsExecutableWithFileInfoAssertCondition : .<.FileInfo>
+    {
+        public FileInfoFileInfoAssertionExtensionsIsExecutableWithFileInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoFileInfoAssertionExtensionsIsHiddenWithFileInfoAssertCondition : .<.FileInfo>
+    {
+        public FileInfoFileInfoAssertionExtensionsIsHiddenWithFileInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoFileInfoAssertionExtensionsIsSystemWithFileInfoAssertCondition : .<.FileInfo>
+    {
+        public FileInfoFileInfoAssertionExtensionsIsSystemWithFileInfoAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class FileInfoIsReadOnlyAssertCondition : .<.FileInfo>
+    {
+        public FileInfoIsReadOnlyAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.FileSystemInfo>("Exists")]
+    [.<.FileSystemInfo>("Exists", CustomName="DoesNotExist", NegateLogic=true)]
+    public static class FileSystemAssertionExtensions
+    {
+        public static .<.FileSystemInfo> DoesNotExist(this ..IValueSource<.FileSystemInfo> valueSource) { }
+        public static .<.FileSystemInfo> Exists(this ..IValueSource<.FileSystemInfo> valueSource) { }
+    }
+    public class FileSystemInfoExistsAssertCondition : .<.FileSystemInfo>
+    {
+        public FileSystemInfoExistsAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.FileSystemInfo? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class GenericIsExtensions
+    {
+        public static .<object> IsAssignableFrom(this ..IValueSource<object> valueSource,  type) { }
+        public static .<object> IsAssignableFrom<TExpected>(this ..IValueSource<object> valueSource) { }
+        public static .<object> IsAssignableTo(this ..IValueSource<object> valueSource,  type) { }
+        public static .<object, TExpected> IsAssignableTo<TExpected>(this ..IValueSource<object> valueSource) { }
+        public static ..GenericEqualToAssertionBuilderWrapper<TActual> IsEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static ..GenericEqualToAssertionBuilderWrapper<TActual> IsEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, .<TActual> equalityComparer, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static .<TActual> IsEquatableOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static ..EquivalentToAssertionBuilderWrapper<TActual, TExpected> IsEquivalentTo<TActual, TExpected>(this ..IValueSource<TActual> valueSource, TExpected expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static .<object> IsNotAssignableFrom(this ..IValueSource<object> valueSource,  type) { }
+        public static .<object> IsNotAssignableFrom<TExpected>(this ..IValueSource<object> valueSource) { }
+        public static .<object> IsNotAssignableTo(this ..IValueSource<object> valueSource,  type) { }
+        public static .<object> IsNotAssignableTo<TExpected>(this ..IValueSource<object> valueSource) { }
+        public static .<object> IsNotTypeOf(this ..IValueSource<object> valueSource,  type) { }
+        public static .<object> IsNotTypeOf<TExpected>(this ..IValueSource<object> valueSource) { }
+        public static .<TActual> IsNull<TActual>(this ..IValueSource<TActual> valueSource) { }
+        public static .<TActual> IsSameReferenceAs<TActual, TExpected>(this ..IValueSource<TActual> valueSource, TExpected expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static .<object> IsTypeOf(this ..IValueSource<object> valueSource,  type) { }
+        public static .<object, TExpected> IsTypeOf<TExpected>(this ..IValueSource<object> valueSource) { }
+    }
+    public static class GenericIsInExtensions
+    {
+        public static .<TActual> IsIn<TActual>(this ..IValueSource<TActual> valueSource, .<TActual> expected) { }
+        public static .<TActual> IsIn<TActual>(this ..IValueSource<TActual> valueSource, params TActual[] expected) { }
+        public static .<TActual> IsIn<TActual>(this ..IValueSource<TActual> valueSource, .<TActual> expected, .<TActual> equalityComparer) { }
+    }
+    public static class GenericIsNotExtensions
+    {
+        public static .<TActual> IsDefault<TActual>(this ..IValueSource<TActual> valueSource) { }
+        public static .<TActual> IsNotDefault<TActual>(this ..IValueSource<TActual> valueSource) { }
+        public static ..GenericNotEqualToAssertionBuilderWrapper<TActual> IsNotEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public static .<TActual> IsNotEquatableOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public static ..NotEquivalentToAssertionBuilderWrapper<TActual, TExpected> IsNotEquivalentTo<TActual, TExpected>(this ..IValueSource<TActual> valueSource, TExpected expected, [.("expected")] string? doNotPopulateThisValue1 = null) { }
+        public static ..NotNullAssertionBuilderWrapper<TActual> IsNotNull<TActual>(this ..IValueSource<TActual?> valueSource)
+            where TActual :  class { }
+        public static ..NotNullStructAssertionBuilderWrapper<TActual> IsNotNull<TActual>(this ..IValueSource<TActual?> valueSource)
+            where TActual :  struct { }
+        public static .<TActual> IsNotSameReferenceAs<TActual, TExpected>(this ..IValueSource<TActual> valueSource, TExpected expected, [.("expected")] string? doNotPopulateThisValue1 = null) { }
+    }
+    public static class GenericSatisfiesExtensions
+    {
+        public static .CollectionWrapper<TInner> All<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<TActual> Satisfies<TActual, TExpected>(this ..IValueSource<TActual> valueSource, <TActual, .<TExpected>?> asyncMapper, <..IValueSource<TExpected?>, .<TExpected?>> assert, [.("asyncMapper")] string mapperExpression = "", [.("assert")] string assertionBuilderExpression = "") { }
+        public static .<TActual> Satisfies<TActual, TExpected>(this ..IValueSource<TActual> valueSource, <TActual, TExpected> mapper, <..IValueSource<TExpected?>, .<TExpected?>> assert, [.("mapper")] string mapperExpression = "", [.("assert")] string assertionBuilderExpression = "") { }
+    }
+    [.<>(typeof(.), "IsEmpty")]
+    [.<>(typeof(.), "IsEmpty", CustomName="IsNotEmpty", NegateLogic=true)]
+    [.<?>(typeof(.), "IsNullOrEmpty")]
+    [.<?>(typeof(.), "IsNullOrEmpty", CustomName="IsNotNullOrEmpty", NegateLogic=true)]
+    public static class GuidAssertionExtensions
+    {
+        public static .<> IsEmpty(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotEmpty(this ..IValueSource<> valueSource) { }
+        public static .<?> IsNotNullOrEmpty(this ..IValueSource<?> valueSource) { }
+        public static .<?> IsNullOrEmpty(this ..IValueSource<?> valueSource) { }
+    }
+    public class GuidGuidAssertionExtensionsIsEmptyWithGuidAssertCondition : .<>
+    {
+        public GuidGuidAssertionExtensionsIsEmptyWithGuidAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class HasExtensions
+    {
+        public static .<.<TInner>, TInner> HasCount<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>, TInner> HasCount<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> HasCount<TInner>(this ..IValueSource<.<TInner>> valueSource, int count) { }
+        public static .<.<TInner>> HasDistinctItems<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> HasDistinctItems<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> HasDistinctItems<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> equalityComparer) { }
+        public static .<.<TInner>> HasDistinctItems<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> equalityComparer) { }
+        public static . HasLength(this ..IValueSource<string> valueSource) { }
+        public static ..Member<TRootObject, TPropertyType> HasMember<TRootObject, TPropertyType>(this ..IValueSource<TRootObject> valueSource, .<<TRootObject, TPropertyType>> selector, [.("selector")] string expression = "") { }
+        public static .<TActual> HasMessageContaining<TActual>(this ..IValueSource<TActual> valueSource, string expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageContaining<TActual>(this ..IValueSource<TActual> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageEndingWith<TActual>(this ..IValueSource<TActual> valueSource, string expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageEndingWith<TActual>(this ..IValueSource<TActual> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageEqualTo<TActual>(this ..IValueSource<TActual> valueSource, string expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageEqualTo<TActual>(this ..IValueSource<TActual> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageMatching<TActual>(this ..IValueSource<TActual> valueSource, . expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageStartingWith<TActual>(this ..IValueSource<TActual> valueSource, string expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual :  { }
+        public static .<TActual> HasMessageStartingWith<TActual>(this ..IValueSource<TActual> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null)
+            where TActual :  { }
+        public static ..SingleItemAssertionBuilderWrapper<.<TInner>, TInner> HasSingleItem<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static ..SingleItemAssertionBuilderWrapper<.<TInner>, TInner> HasSingleItem<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+    }
+    [.<.HttpStatusCode>(typeof(.), "IsClientError")]
+    [.<.HttpStatusCode>(typeof(.), "IsClientError", CustomName="IsNotClientError", NegateLogic=true)]
+    [.<.HttpStatusCode>(typeof(.), "IsError")]
+    [.<.HttpStatusCode>(typeof(.), "IsError", CustomName="IsNotError", NegateLogic=true)]
+    [.<.HttpStatusCode>(typeof(.), "IsInformational")]
+    [.<.HttpStatusCode>(typeof(.), "IsInformational", CustomName="IsNotInformational", NegateLogic=true)]
+    [.<.HttpStatusCode>(typeof(.), "IsRedirection")]
+    [.<.HttpStatusCode>(typeof(.), "IsRedirection", CustomName="IsNotRedirection", NegateLogic=true)]
+    [.<.HttpStatusCode>(typeof(.), "IsServerError")]
+    [.<.HttpStatusCode>(typeof(.), "IsServerError", CustomName="IsNotServerError", NegateLogic=true)]
+    [.<.HttpStatusCode>(typeof(.), "IsSuccess")]
+    [.<.HttpStatusCode>(typeof(.), "IsSuccess", CustomName="IsNotSuccess", NegateLogic=true)]
+    public static class HttpStatusCodeAssertionExtensions
+    {
+        public static .<.HttpStatusCode> IsClientError(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsError(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsInformational(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsNotClientError(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsNotError(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsNotInformational(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsNotRedirection(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsNotServerError(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsNotSuccess(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsRedirection(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsServerError(this ..IValueSource<.HttpStatusCode> valueSource) { }
+        public static .<.HttpStatusCode> IsSuccess(this ..IValueSource<.HttpStatusCode> valueSource) { }
+    }
+    public class HttpStatusCodeHttpStatusCodeAssertionExtensionsIsClientErrorWithHttpStatusCodeAssertCondition : .<.HttpStatusCode>
+    {
+        public HttpStatusCodeHttpStatusCodeAssertionExtensionsIsClientErrorWithHttpStatusCodeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.HttpStatusCode actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class HttpStatusCodeHttpStatusCodeAssertionExtensionsIsErrorWithHttpStatusCodeAssertCondition : .<.HttpStatusCode>
+    {
+        public HttpStatusCodeHttpStatusCodeAssertionExtensionsIsErrorWithHttpStatusCodeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.HttpStatusCode actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class HttpStatusCodeHttpStatusCodeAssertionExtensionsIsInformationalWithHttpStatusCodeAssertCondition : .<.HttpStatusCode>
+    {
+        public HttpStatusCodeHttpStatusCodeAssertionExtensionsIsInformationalWithHttpStatusCodeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.HttpStatusCode actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class HttpStatusCodeHttpStatusCodeAssertionExtensionsIsRedirectionWithHttpStatusCodeAssertCondition : .<.HttpStatusCode>
+    {
+        public HttpStatusCodeHttpStatusCodeAssertionExtensionsIsRedirectionWithHttpStatusCodeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.HttpStatusCode actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class HttpStatusCodeHttpStatusCodeAssertionExtensionsIsServerErrorWithHttpStatusCodeAssertCondition : .<.HttpStatusCode>
+    {
+        public HttpStatusCodeHttpStatusCodeAssertionExtensionsIsServerErrorWithHttpStatusCodeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.HttpStatusCode actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class HttpStatusCodeHttpStatusCodeAssertionExtensionsIsSuccessWithHttpStatusCodeAssertCondition : .<.HttpStatusCode>
+    {
+        public HttpStatusCodeHttpStatusCodeAssertionExtensionsIsSuccessWithHttpStatusCodeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.HttpStatusCode actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.IPAddress>("IsIPv4MappedToIPv6")]
+    [.<.IPAddress>("IsIPv4MappedToIPv6", CustomName="IsNotIPv4MappedToIPv6", NegateLogic=true)]
+    [.<.IPAddress>("IsIPv6LinkLocal")]
+    [.<.IPAddress>("IsIPv6LinkLocal", CustomName="IsNotIPv6LinkLocal", NegateLogic=true)]
+    [.<.IPAddress>("IsIPv6Multicast")]
+    [.<.IPAddress>("IsIPv6Multicast", CustomName="IsNotIPv6Multicast", NegateLogic=true)]
+    [.<.IPAddress>("IsIPv6SiteLocal")]
+    [.<.IPAddress>("IsIPv6SiteLocal", CustomName="IsNotIPv6SiteLocal", NegateLogic=true)]
+    [.<.IPAddress>(typeof(.), "IsIPv4")]
+    [.<.IPAddress>(typeof(.), "IsIPv4", CustomName="IsNotIPv4", NegateLogic=true)]
+    [.<.IPAddress>(typeof(.), "IsIPv6")]
+    [.<.IPAddress>(typeof(.), "IsIPv6", CustomName="IsNotIPv6", NegateLogic=true)]
+    [.<.IPAddress>(typeof(.), "IsLoopback")]
+    [.<.IPAddress>(typeof(.), "IsLoopback", CustomName="IsNotLoopback", NegateLogic=true)]
+    [.<.IPAddress>(typeof(.), "IsPrivate")]
+    [.<.IPAddress>(typeof(.), "IsPrivate", CustomName="IsPublic", NegateLogic=true)]
+    public static class IPAddressAssertionExtensions
+    {
+        public static .<.IPAddress> IsIPv4(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsIPv4MappedToIPv6(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsIPv6(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsIPv6LinkLocal(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsIPv6Multicast(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsIPv6SiteLocal(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsLoopback(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotIPv4(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotIPv4MappedToIPv6(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotIPv6(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotIPv6LinkLocal(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotIPv6Multicast(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotIPv6SiteLocal(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsNotLoopback(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsPrivate(this ..IValueSource<.IPAddress> valueSource) { }
+        public static .<.IPAddress> IsPublic(this ..IValueSource<.IPAddress> valueSource) { }
+    }
+    public class IPAddressIPAddressAssertionExtensionsIsIPv4WithIPAddressAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIPAddressAssertionExtensionsIsIPv4WithIPAddressAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIPAddressAssertionExtensionsIsIPv6WithIPAddressAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIPAddressAssertionExtensionsIsIPv6WithIPAddressAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIPAddressAssertionExtensionsIsLoopbackWithIPAddressAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIPAddressAssertionExtensionsIsLoopbackWithIPAddressAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIPAddressAssertionExtensionsIsPrivateWithIPAddressAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIPAddressAssertionExtensionsIsPrivateWithIPAddressAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIsIPv4MappedToIPv6AssertCondition : .<.IPAddress>
+    {
+        public IPAddressIsIPv4MappedToIPv6AssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIsIPv6LinkLocalAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIsIPv6LinkLocalAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIsIPv6MulticastAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIsIPv6MulticastAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class IPAddressIsIPv6SiteLocalAssertCondition : .<.IPAddress>
+    {
+        public IPAddressIsIPv6SiteLocalAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.IPAddress? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class ImmutableArrayIsExtensions
+    {
+        public static .<.<TInner>> IsEmpty<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, .<TInner> comparer, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, .<TInner> comparer, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsInDescendingOrder<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsInDescendingOrder<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> comparer) { }
+        public static .<.<TInner>> IsInOrder<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsInOrder<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> comparer) { }
+        public static .<.<TInner>> IsOrderedBy<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, [.("comparisonItemSelector")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsOrderedBy<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, .<TComparisonItem> comparer, [.("comparisonItemSelector")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null) { }
+        public static .<.<TInner>> IsOrderedByDescending<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, [.("comparisonItemSelector")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsOrderedByDescending<TInner, TComparisonItem>(this ..IValueSource<.<TInner>> valueSource, <TInner, TComparisonItem> comparisonItemSelector, .<TComparisonItem> comparer, [.("comparisonItemSelector")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null) { }
+    }
+    public static class ImmutableArrayIsNotExtensions
+    {
+        public static .<.<TInner>> IsNotEmpty<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsNotEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<.<TInner>> IsNotEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, .<TInner> comparer, [.("expected")] string doNotPopulateThisValue = null, [.("comparer")] string doNotPopulateThisValue2 = null) { }
+        public static .<.<TInner>> IsNotEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null, [.("collectionOrdering")] string doNotPopulateThisValue2 = null) { }
+        public static .<.<TInner>> IsNotEquivalentTo<TInner>(this ..IValueSource<.<TInner>> valueSource, .<TInner> expected, .<TInner> comparer, . collectionOrdering, [.("expected")] string doNotPopulateThisValue = null, [.("collectionOrdering")] string doNotPopulateThisValue2 = null) { }
+    }
+    public class NullableGuidAssertionExtensionsIsNullOrEmptyWithNullableAssertCondition : .<?>
+    {
+        public NullableGuidAssertionExtensionsIsNullOrEmptyWithNullableAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<string>(typeof(.Path), "IsPathRooted", CustomName="IsNotRootedPath", NegateLogic=true)]
+    [.<string>(typeof(.Path), "IsPathRooted", CustomName="IsRootedPath")]
+    public static class PathAssertionExtensions
+    {
+        public static .<string> IsNotRootedPath(this ..IValueSource<string> valueSource) { }
+        public static .<string> IsRootedPath(this ..IValueSource<string> valueSource) { }
+    }
+    [.<.>(typeof(.), "HasTimeout")]
+    [.<.>(typeof(.), "HasTimeout", CustomName="HasNoTimeout", NegateLogic=true)]
+    [.<.>(typeof(.), "IsCaseInsensitive")]
+    [.<.>(typeof(.), "IsCaseInsensitive", CustomName="IsCaseSensitive", NegateLogic=true)]
+    [.<.>(typeof(.), "IsCompiled")]
+    [.<.>(typeof(.), "IsCompiled", CustomName="IsNotCompiled", NegateLogic=true)]
+    [.<.>(typeof(.), "IsMultiline")]
+    [.<.>(typeof(.), "IsMultiline", CustomName="IsSingleline", NegateLogic=true)]
+    public static class RegexAssertionExtensions
+    {
+        public static .<.> HasNoTimeout(this ..IValueSource<.> valueSource) { }
+        public static .<.> HasTimeout(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsCaseInsensitive(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsCaseSensitive(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsCompiled(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsMultiline(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotCompiled(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsSingleline(this ..IValueSource<.> valueSource) { }
+    }
+    public class RegexRegexAssertionExtensionsHasTimeoutWithRegexAssertCondition : .<.>
+    {
+        public RegexRegexAssertionExtensionsHasTimeoutWithRegexAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class RegexRegexAssertionExtensionsIsCaseInsensitiveWithRegexAssertCondition : .<.>
+    {
+        public RegexRegexAssertionExtensionsIsCaseInsensitiveWithRegexAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class RegexRegexAssertionExtensionsIsCompiledWithRegexAssertCondition : .<.>
+    {
+        public RegexRegexAssertionExtensionsIsCompiledWithRegexAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class RegexRegexAssertionExtensionsIsMultilineWithRegexAssertCondition : .<.>
+    {
+        public RegexRegexAssertionExtensionsIsMultilineWithRegexAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class SourceExtensions
+    {
+        public static . RegisterAssertion<TActual>(this ..IDelegateSource delegateSource, .<TActual> assertCondition, string?[] argumentExpressions, [.] string? caller = null) { }
+        public static .<TActual> RegisterAssertion<TActual>(this ..IValueSource<TActual> source, .<TActual> assertCondition, string?[] argumentExpressions, [.] string? caller = null) { }
+        public static .<TToType> RegisterConversionAssertion<TToType>(this ..IDelegateSource source)
+            where TToType :  { }
+        public static .<TToType> RegisterConversionAssertion<TFromType, TToType>(this ..IValueSource<TFromType> source, .<TFromType, TToType> assertCondition, string?[] argumentExpressions, [.] string? caller = null) { }
+    }
+    [.<.Stream>("CanRead")]
+    [.<.Stream>("CanRead", CustomName="CannotRead", NegateLogic=true)]
+    [.<.Stream>("CanSeek")]
+    [.<.Stream>("CanSeek", CustomName="CannotSeek", NegateLogic=true)]
+    [.<.Stream>("CanWrite")]
+    [.<.Stream>("CanWrite", CustomName="CannotWrite", NegateLogic=true)]
+    [.<.Stream>(typeof(.), "IsAtEnd")]
+    [.<.Stream>(typeof(.), "IsAtEnd", CustomName="IsNotAtEnd", NegateLogic=true)]
+    [.<.Stream>(typeof(.), "IsAtStart")]
+    [.<.Stream>(typeof(.), "IsAtStart", CustomName="IsNotAtStart", NegateLogic=true)]
+    [.<.Stream>(typeof(.), "IsEmpty")]
+    [.<.Stream>(typeof(.), "IsEmpty", CustomName="IsNotEmpty", NegateLogic=true)]
+    public static class StreamAssertionExtensions
+    {
+        public static .<.Stream> CanRead(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> CanSeek(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> CanWrite(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> CannotRead(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> CannotSeek(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> CannotWrite(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> IsAtEnd(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> IsAtStart(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> IsEmpty(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> IsNotAtEnd(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> IsNotAtStart(this ..IValueSource<.Stream> valueSource) { }
+        public static .<.Stream> IsNotEmpty(this ..IValueSource<.Stream> valueSource) { }
+    }
+    public class StreamCanReadAssertCondition : .<.Stream>
+    {
+        public StreamCanReadAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Stream? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StreamCanSeekAssertCondition : .<.Stream>
+    {
+        public StreamCanSeekAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Stream? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StreamCanWriteAssertCondition : .<.Stream>
+    {
+        public StreamCanWriteAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Stream? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StreamStreamAssertionExtensionsIsAtEndWithStreamAssertCondition : .<.Stream>
+    {
+        public StreamStreamAssertionExtensionsIsAtEndWithStreamAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Stream? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StreamStreamAssertionExtensionsIsAtStartWithStreamAssertCondition : .<.Stream>
+    {
+        public StreamStreamAssertionExtensionsIsAtStartWithStreamAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Stream? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StreamStreamAssertionExtensionsIsEmptyWithStreamAssertCondition : .<.Stream>
+    {
+        public StreamStreamAssertionExtensionsIsEmptyWithStreamAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Stream? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<string>("Contains", CustomName="DoesNotContain", NegateLogic=true)]
+    [.<string>("EndsWith", CustomName="DoesNotEndWith", NegateLogic=true)]
+    [.<string>("EndsWith", CustomName="EndsWith")]
+    [.<string>("StartsWith", CustomName="DoesNotStartWith", NegateLogic=true)]
+    [.<string>("StartsWith", CustomName="StartsWith")]
+    public static class StringAssertionExtensions
+    {
+        public static .<string> DoesNotContain(this ..IValueSource<string> valueSource, string value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> DoesNotEndWith(this ..IValueSource<string> valueSource, string value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> DoesNotEndWith(this ..IValueSource<string> valueSource, string value,  comparisonType, [.("value")] string? doNotPopulateThisValue1 = null, [.("comparisonType")] string? doNotPopulateThisValue2 = null) { }
+        public static .<string> DoesNotEndWith(this ..IValueSource<string> valueSource, string value, bool ignoreCase, .CultureInfo culture, [.("value")] string? doNotPopulateThisValue1 = null, [.("ignoreCase")] string? doNotPopulateThisValue2 = null, [.("culture")] string? doNotPopulateThisValue3 = null) { }
+        public static .<string> DoesNotStartWith(this ..IValueSource<string> valueSource, string value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> DoesNotStartWith(this ..IValueSource<string> valueSource, string value,  comparisonType, [.("value")] string? doNotPopulateThisValue1 = null, [.("comparisonType")] string? doNotPopulateThisValue2 = null) { }
+        public static .<string> DoesNotStartWith(this ..IValueSource<string> valueSource, string value, bool ignoreCase, .CultureInfo culture, [.("value")] string? doNotPopulateThisValue1 = null, [.("ignoreCase")] string? doNotPopulateThisValue2 = null, [.("culture")] string? doNotPopulateThisValue3 = null) { }
+        public static .<string> EndsWith(this ..IValueSource<string> valueSource, string value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> EndsWith(this ..IValueSource<string> valueSource, string value,  comparisonType, [.("value")] string? doNotPopulateThisValue1 = null, [.("comparisonType")] string? doNotPopulateThisValue2 = null) { }
+        public static .<string> EndsWith(this ..IValueSource<string> valueSource, string value, bool ignoreCase, .CultureInfo culture, [.("value")] string? doNotPopulateThisValue1 = null, [.("ignoreCase")] string? doNotPopulateThisValue2 = null, [.("culture")] string? doNotPopulateThisValue3 = null) { }
+        public static .<string> StartsWith(this ..IValueSource<string> valueSource, string value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> StartsWith(this ..IValueSource<string> valueSource, string value,  comparisonType, [.("value")] string? doNotPopulateThisValue1 = null, [.("comparisonType")] string? doNotPopulateThisValue2 = null) { }
+        public static .<string> StartsWith(this ..IValueSource<string> valueSource, string value, bool ignoreCase, .CultureInfo culture, [.("value")] string? doNotPopulateThisValue1 = null, [.("ignoreCase")] string? doNotPopulateThisValue2 = null, [.("culture")] string? doNotPopulateThisValue3 = null) { }
+    }
+    [.<.StringBuilder>(typeof(.), "HasExcessCapacity")]
+    [.<.StringBuilder>(typeof(.), "HasExcessCapacity", CustomName="HasNoExcessCapacity", NegateLogic=true)]
+    [.<.StringBuilder>(typeof(.), "IsAtCapacity")]
+    [.<.StringBuilder>(typeof(.), "IsAtCapacity", CustomName="IsNotAtCapacity", NegateLogic=true)]
+    [.<.StringBuilder>(typeof(.), "IsEmpty")]
+    [.<.StringBuilder>(typeof(.), "IsEmpty", CustomName="IsNotEmpty", NegateLogic=true)]
+    public static class StringBuilderAssertionExtensions
+    {
+        public static .<.StringBuilder> HasExcessCapacity(this ..IValueSource<.StringBuilder> valueSource) { }
+        public static .<.StringBuilder> HasNoExcessCapacity(this ..IValueSource<.StringBuilder> valueSource) { }
+        public static .<.StringBuilder> IsAtCapacity(this ..IValueSource<.StringBuilder> valueSource) { }
+        public static .<.StringBuilder> IsEmpty(this ..IValueSource<.StringBuilder> valueSource) { }
+        public static .<.StringBuilder> IsNotAtCapacity(this ..IValueSource<.StringBuilder> valueSource) { }
+        public static .<.StringBuilder> IsNotEmpty(this ..IValueSource<.StringBuilder> valueSource) { }
+    }
+    public class StringBuilderStringBuilderAssertionExtensionsHasExcessCapacityWithStringBuilderAssertCondition : .<.StringBuilder>
+    {
+        public StringBuilderStringBuilderAssertionExtensionsHasExcessCapacityWithStringBuilderAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.StringBuilder? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringBuilderStringBuilderAssertionExtensionsIsAtCapacityWithStringBuilderAssertCondition : .<.StringBuilder>
+    {
+        public StringBuilderStringBuilderAssertionExtensionsIsAtCapacityWithStringBuilderAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.StringBuilder? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringBuilderStringBuilderAssertionExtensionsIsEmptyWithStringBuilderAssertCondition : .<.StringBuilder>
+    {
+        public StringBuilderStringBuilderAssertionExtensionsIsEmptyWithStringBuilderAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.StringBuilder? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringContainsWithStringAssertCondition : .<string>
+    {
+        public StringContainsWithStringAssertCondition(string value, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringEndsWithWithStringAnd1MoreAssertCondition : .<string>
+    {
+        public StringEndsWithWithStringAnd1MoreAssertCondition(string value,  comparisonType, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringEndsWithWithStringAnd2MoreAssertCondition : .<string>
+    {
+        public StringEndsWithWithStringAnd2MoreAssertCondition(string value, bool ignoreCase, .CultureInfo culture, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringEndsWithWithStringAssertCondition : .<string>
+    {
+        public StringEndsWithWithStringAssertCondition(string value, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class StringExtensions
+    {
+        public static string GetStringOr(this string? value, string defaultValue) { }
+        public static string GetStringOrEmpty(this string? value) { }
+        public static string PrependAOrAn(this string value) { }
+        public static string ReplaceNewLines(this string value) { }
+        public static string ShowNewLines(this string value) { }
+        public static string TruncateWithEllipsis(this string value, int maxLength) { }
+    }
+    public static class StringIsExtensions
+    {
+        public static .<string> IsEmpty(this ..IValueSource<string> valueSource) { }
+        public static ..StringEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<string> valueSource, string expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static ..StringEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<string> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null) { }
+        public static .<string> IsNullOrEmpty(this ..IValueSource<string> valueSource) { }
+        public static .<string> IsNullOrWhitespace(this ..IValueSource<string> valueSource) { }
+    }
+    public static class StringIsNotExtensions
+    {
+        public static .<string> IsNotEmpty(this ..IValueSource<string> valueSource) { }
+        public static .<string> IsNotEqualTo(this ..IValueSource<string> valueSource, string expected, [.("expected")] string doNotPopulateThisValue = null) { }
+        public static .<string> IsNotEqualTo(this ..IValueSource<string> valueSource, string expected,  stringComparison, [.("expected")] string doNotPopulateThisValue1 = null, [.("stringComparison")] string doNotPopulateThisValue2 = null) { }
+        public static .<string> IsNotNullOrEmpty(this ..IValueSource<string> valueSource) { }
+        public static .<string> IsNotNullOrWhitespace(this ..IValueSource<string> valueSource) { }
+    }
+    public class StringLength
+    {
+        public StringLength(..IValueSource<string> valueSource) { }
+        public .<string> Positive { get; }
+        public .<string> Zero { get; }
+        public .<string> EqualTo(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<string> GreaterThan(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<string> GreaterThanOrEqualTo(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<string> LessThan(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<string> LessThanOrEqualTo(int expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+    }
+    public class StringPathIsPathRootedWithStringAssertCondition : .<string>
+    {
+        public StringPathIsPathRootedWithStringAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringStartsWithWithStringAnd1MoreAssertCondition : .<string>
+    {
+        public StringStartsWithWithStringAnd1MoreAssertCondition(string value,  comparisonType, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringStartsWithWithStringAnd2MoreAssertCondition : .<string>
+    {
+        public StringStartsWithWithStringAnd2MoreAssertCondition(string value, bool ignoreCase, .CultureInfo culture, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringStartsWithWithStringAssertCondition : .<string>
+    {
+        public StringStartsWithWithStringAssertCondition(string value, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringUriIsHexEncodingWithStringAnd1MoreAssertCondition : .<string>
+    {
+        public StringUriIsHexEncodingWithStringAnd1MoreAssertCondition(int index, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringUriIsWellFormedUriStringWithStringAnd1MoreAssertCondition : .<string>
+    {
+        public StringUriIsWellFormedUriStringWithStringAnd1MoreAssertCondition( uriKind, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.>("IsCanceled")]
+    [.<.>("IsCanceled", CustomName="IsNotCanceled", NegateLogic=true)]
+    [.<.>("IsCompleted")]
+    [.<.>("IsCompleted", CustomName="IsNotCompleted", NegateLogic=true)]
+    [.<.>("IsFaulted")]
+    [.<.>("IsFaulted", CustomName="IsNotFaulted", NegateLogic=true)]
+    public static class TaskAssertionExtensions
+    {
+        public static .<.> IsCanceled(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsCompleted(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsFaulted(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotCanceled(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotCompleted(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotFaulted(this ..IValueSource<.> valueSource) { }
+    }
+    public class TaskIsCanceledAssertCondition : .<.>
+    {
+        public TaskIsCanceledAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TaskIsCompletedAssertCondition : .<.>
+    {
+        public TaskIsCompletedAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TaskIsFaultedAssertCondition : .<.>
+    {
+        public TaskIsFaultedAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class ThrowsException<TActual, TException>
+        where TException : 
+    {
+        public ThrowsException(. delegateAssertionBuilder, ..IDelegateSource source, <?, ?> selector) { }
+        public ..ValueAnd<TException> And { get; }
+        public ..DelegateOr<object?> Or { get; }
+        public .<TException?> GetAwaiter() { }
+        public .<TActual, > WithInnerException() { }
+        public .<TActual, TException> WithMessage(string expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual, TException> WithMessageContaining(string expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual, TException> WithMessageContaining(string expected,  stringComparison, [.("expected")] string? doNotPopulateThisValue = null, [.("stringComparison")] string? doNotPopulateThisValue2 = null) { }
+        public .<TActual, TException> WithMessageMatching(. match, [.("match")] string? doNotPopulateThisValue = null) { }
+        public .<TActual, TException> WithMessageNotContaining(string expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        public .<TActual, TException> WithMessageNotContaining(string expected,  stringComparison, [.("expected")] string? doNotPopulateThisValue = null, [.("stringComparison")] string? doNotPopulateThisValue2 = null) { }
+        public static .<TException?> op_Explicit(.<TActual, TException> throwsException) { }
+    }
+    public static class ThrowsExtensions
+    {
+        public static .<object?, > Throws(this ..IDelegateSource delegateSource,  type, [.("type")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, TException> Throws<TException>(this ..IDelegateSource delegateSource)
+            where TException :  { }
+        public static .<object?, TException> ThrowsExactly<TException>(this ..IDelegateSource delegateSource)
+            where TException :  { }
+        public static .<object?, > ThrowsException(this ..IDelegateSource delegateSource) { }
+        public static .<object?, object?> ThrowsNothing(this ..IDelegateSource delegateSource) { }
+        public static .<TActual, TActual> ThrowsNothing<TActual>(this ..IValueDelegateSource<TActual> delegateSource) { }
+        public static .<object?, > ThrowsWithin(this ..IDelegateSource delegateSource,  timeSpan, [.("timeSpan")] string? doNotPopulateThisValue = null) { }
+        public static .<object?, TException> ThrowsWithin<TException>(this ..IDelegateSource delegateSource,  timeSpan, [.("timeSpan")] string? doNotPopulateThisValue = null)
+            where TException :  { }
+        public static .<TActual, TException> WithParameterName<TActual, TException>(this .<TActual, TException> throwsException, string expected, [.("expected")] string? doNotPopulateThisValue = null)
+            where TException :  { }
+    }
+    [.<>(typeof(.), "IsNegative")]
+    [.<>(typeof(.), "IsNegative", CustomName="IsPositiveOrZero", NegateLogic=true)]
+    [.<>(typeof(.), "IsPositive")]
+    [.<>(typeof(.), "IsPositive", CustomName="IsNegativeOrZero", NegateLogic=true)]
+    [.<>(typeof(.), "IsZero")]
+    [.<>(typeof(.), "IsZero", CustomName="IsNotZero", NegateLogic=true)]
+    public static class TimeSpanAssertionExtensions
+    {
+        public static .<> IsNegative(this ..IValueSource<> valueSource) { }
+        public static .<> IsNegativeOrZero(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotZero(this ..IValueSource<> valueSource) { }
+        public static .<> IsPositive(this ..IValueSource<> valueSource) { }
+        public static .<> IsPositiveOrZero(this ..IValueSource<> valueSource) { }
+        public static .<> IsZero(this ..IValueSource<> valueSource) { }
+    }
+    public static class TimeSpanExtensions
+    {
+        public static  Days(this int days) { }
+        public static  Hours(this int hours) { }
+        public static  Milliseconds(this int milliseconds) { }
+        public static  Minutes(this int minutes) { }
+        public static  Seconds(this int seconds) { }
+    }
+    public static class TimeSpanIsExtensions
+    {
+        public static ..TimeSpanEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+        public static .<> IsZero(this ..IValueSource<> valueSource) { }
+    }
+    public static class TimeSpanIsNotExtensions
+    {
+        public static .<> IsNotZero(this ..IValueSource<> valueSource) { }
+    }
+    public class TimeSpanTimeSpanAssertionExtensionsIsNegativeWithTimeSpanAssertCondition : .<>
+    {
+        public TimeSpanTimeSpanAssertionExtensionsIsNegativeWithTimeSpanAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TimeSpanTimeSpanAssertionExtensionsIsPositiveWithTimeSpanAssertCondition : .<>
+    {
+        public TimeSpanTimeSpanAssertionExtensionsIsPositiveWithTimeSpanAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TimeSpanTimeSpanAssertionExtensionsIsZeroWithTimeSpanAssertCondition : .<>
+    {
+        public TimeSpanTimeSpanAssertionExtensionsIsZeroWithTimeSpanAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<>("IsAbstract")]
+    [.<>("IsAbstract", CustomName="IsNotAbstract", NegateLogic=true)]
+    [.<>("IsArray")]
+    [.<>("IsArray", CustomName="IsNotArray", NegateLogic=true)]
+    [.<>("IsAssignableFrom")]
+    [.<>("IsAssignableFrom", CustomName="IsNotAssignableFrom", NegateLogic=true)]
+    [.<>("IsClass")]
+    [.<>("IsClass", CustomName="IsNotClass", NegateLogic=true)]
+    [.<>("IsEnum")]
+    [.<>("IsEnum", CustomName="IsNotEnum", NegateLogic=true)]
+    [.<>("IsGenericType")]
+    [.<>("IsGenericType", CustomName="IsNotGenericType", NegateLogic=true)]
+    [.<>("IsGenericTypeDefinition")]
+    [.<>("IsGenericTypeDefinition", CustomName="IsNotGenericTypeDefinition", NegateLogic=true)]
+    [.<>("IsInterface")]
+    [.<>("IsInterface", CustomName="IsNotInterface", NegateLogic=true)]
+    [.<>("IsNested")]
+    [.<>("IsNested", CustomName="IsNotNested", NegateLogic=true)]
+    [.<>("IsPrimitive")]
+    [.<>("IsPrimitive", CustomName="IsNotPrimitive", NegateLogic=true)]
+    [.<>("IsPublic")]
+    [.<>("IsPublic", CustomName="IsNotPublic", NegateLogic=true)]
+    [.<>("IsSealed")]
+    [.<>("IsSealed", CustomName="IsNotSealed", NegateLogic=true)]
+    [.<>("IsSerializable")]
+    [.<>("IsSerializable", CustomName="IsNotSerializable", NegateLogic=true)]
+    [.<>("IsValueType")]
+    [.<>("IsValueType", CustomName="IsReferenceType", NegateLogic=true)]
+    public static class TypeAssertionExtensions
+    {
+        public static .<> IsAbstract(this ..IValueSource<> valueSource) { }
+        public static .<> IsArray(this ..IValueSource<> valueSource) { }
+        public static .<> IsAssignableFrom(this ..IValueSource<> valueSource,  c, [.("c")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsClass(this ..IValueSource<> valueSource) { }
+        public static .<> IsEnum(this ..IValueSource<> valueSource) { }
+        public static .<> IsGenericType(this ..IValueSource<> valueSource) { }
+        public static .<> IsGenericTypeDefinition(this ..IValueSource<> valueSource) { }
+        public static .<> IsInterface(this ..IValueSource<> valueSource) { }
+        public static .<> IsNested(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotAbstract(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotArray(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotAssignableFrom(this ..IValueSource<> valueSource,  c, [.("c")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsNotClass(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotEnum(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotGenericType(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotGenericTypeDefinition(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotInterface(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotNested(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotPrimitive(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotPublic(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotSealed(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotSerializable(this ..IValueSource<> valueSource) { }
+        public static .<> IsPrimitive(this ..IValueSource<> valueSource) { }
+        public static .<> IsPublic(this ..IValueSource<> valueSource) { }
+        public static .<> IsReferenceType(this ..IValueSource<> valueSource) { }
+        public static .<> IsSealed(this ..IValueSource<> valueSource) { }
+        public static .<> IsSerializable(this ..IValueSource<> valueSource) { }
+        public static .<> IsValueType(this ..IValueSource<> valueSource) { }
+    }
+    public class TypeIsAbstractAssertCondition : .<>
+    {
+        public TypeIsAbstractAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsArrayAssertCondition : .<>
+    {
+        public TypeIsArrayAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsAssignableFromWithTypeAssertCondition : .<>
+    {
+        public TypeIsAssignableFromWithTypeAssertCondition( c, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsClassAssertCondition : .<>
+    {
+        public TypeIsClassAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsEnumAssertCondition : .<>
+    {
+        public TypeIsEnumAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsGenericTypeAssertCondition : .<>
+    {
+        public TypeIsGenericTypeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsGenericTypeDefinitionAssertCondition : .<>
+    {
+        public TypeIsGenericTypeDefinitionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsInterfaceAssertCondition : .<>
+    {
+        public TypeIsInterfaceAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsNestedAssertCondition : .<>
+    {
+        public TypeIsNestedAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsPrimitiveAssertCondition : .<>
+    {
+        public TypeIsPrimitiveAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsPublicAssertCondition : .<>
+    {
+        public TypeIsPublicAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsSealedAssertCondition : .<>
+    {
+        public TypeIsSealedAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsSerializableAssertCondition : .<>
+    {
+        public TypeIsSerializableAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class TypeIsValueTypeAssertCondition : .<>
+    {
+        public TypeIsValueTypeAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<char>(typeof(), "IsHexDigit")]
+    [.<char>(typeof(), "IsHexDigit", CustomName="IsNotHexDigit", NegateLogic=true)]
+    [.<string>(typeof(), "IsHexEncoding")]
+    [.<string>(typeof(), "IsHexEncoding", CustomName="IsNotHexEncoding", NegateLogic=true)]
+    [.<string>(typeof(), "IsWellFormedUriString")]
+    [.<string>(typeof(), "IsWellFormedUriString", CustomName="IsNotWellFormedUriString", NegateLogic=true)]
+    [.<>("IsAbsoluteUri")]
+    [.<>("IsAbsoluteUri", CustomName="IsNotAbsoluteUri", NegateLogic=true)]
+    [.<>("IsBaseOf")]
+    [.<>("IsBaseOf", CustomName="IsNotBaseOf", NegateLogic=true)]
+    [.<>("IsDefaultPort")]
+    [.<>("IsDefaultPort", CustomName="IsNotDefaultPort", NegateLogic=true)]
+    [.<>("IsFile")]
+    [.<>("IsFile", CustomName="IsNotFile", NegateLogic=true)]
+    [.<>("IsLoopback")]
+    [.<>("IsLoopback", CustomName="IsNotLoopback", NegateLogic=true)]
+    [.<>("IsUnc")]
+    [.<>("IsUnc", CustomName="IsNotUnc", NegateLogic=true)]
+    [.<>("IsWellFormedOriginalString")]
+    [.<>("IsWellFormedOriginalString", CustomName="IsNotWellFormedOriginalString", NegateLogic=true)]
+    [.<>(typeof(.), "IsHttp")]
+    [.<>(typeof(.), "IsHttp", CustomName="IsNotHttp", NegateLogic=true)]
+    [.<>(typeof(.), "IsHttpOrHttps")]
+    [.<>(typeof(.), "IsHttpOrHttps", CustomName="IsNotHttpOrHttps", NegateLogic=true)]
+    [.<>(typeof(.), "IsHttps")]
+    [.<>(typeof(.), "IsHttps", CustomName="IsNotHttps", NegateLogic=true)]
+    public static class UriAssertionExtensions
+    {
+        public static .<> IsAbsoluteUri(this ..IValueSource<> valueSource) { }
+        public static .<> IsBaseOf(this ..IValueSource<> valueSource,  uri, [.("uri")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsDefaultPort(this ..IValueSource<> valueSource) { }
+        public static .<> IsFile(this ..IValueSource<> valueSource) { }
+        public static .<char> IsHexDigit(this ..IValueSource<char> valueSource) { }
+        public static .<string> IsHexEncoding(this ..IValueSource<string> valueSource, int index, [.("index")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsHttp(this ..IValueSource<> valueSource) { }
+        public static .<> IsHttpOrHttps(this ..IValueSource<> valueSource) { }
+        public static .<> IsHttps(this ..IValueSource<> valueSource) { }
+        public static .<> IsLoopback(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotAbsoluteUri(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotBaseOf(this ..IValueSource<> valueSource,  uri, [.("uri")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsNotDefaultPort(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotFile(this ..IValueSource<> valueSource) { }
+        public static .<char> IsNotHexDigit(this ..IValueSource<char> valueSource) { }
+        public static .<string> IsNotHexEncoding(this ..IValueSource<string> valueSource, int index, [.("index")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsNotHttp(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotHttpOrHttps(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotHttps(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotLoopback(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotUnc(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotWellFormedOriginalString(this ..IValueSource<> valueSource) { }
+        public static .<string> IsNotWellFormedUriString(this ..IValueSource<string> valueSource,  uriKind, [.("uriKind")] string? doNotPopulateThisValue1 = null) { }
+        public static .<> IsUnc(this ..IValueSource<> valueSource) { }
+        public static .<> IsWellFormedOriginalString(this ..IValueSource<> valueSource) { }
+        public static .<string> IsWellFormedUriString(this ..IValueSource<string> valueSource,  uriKind, [.("uriKind")] string? doNotPopulateThisValue1 = null) { }
+    }
+    public class UriIsAbsoluteUriAssertCondition : .<>
+    {
+        public UriIsAbsoluteUriAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriIsBaseOfWithUriAssertCondition : .<>
+    {
+        public UriIsBaseOfWithUriAssertCondition( uri, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriIsDefaultPortAssertCondition : .<>
+    {
+        public UriIsDefaultPortAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriIsFileAssertCondition : .<>
+    {
+        public UriIsFileAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriIsLoopbackAssertCondition : .<>
+    {
+        public UriIsLoopbackAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriIsUncAssertCondition : .<>
+    {
+        public UriIsUncAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriIsWellFormedOriginalStringAssertCondition : .<>
+    {
+        public UriIsWellFormedOriginalStringAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriUriAssertionExtensionsIsHttpOrHttpsWithUriAssertCondition : .<>
+    {
+        public UriUriAssertionExtensionsIsHttpOrHttpsWithUriAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriUriAssertionExtensionsIsHttpWithUriAssertCondition : .<>
+    {
+        public UriUriAssertionExtensionsIsHttpWithUriAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class UriUriAssertionExtensionsIsHttpsWithUriAssertCondition : .<>
+    {
+        public UriUriAssertionExtensionsIsHttpsWithUriAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<>(typeof(.), "IsMajorVersion")]
+    [.<>(typeof(.), "IsMajorVersion", CustomName="IsNotMajorVersion", NegateLogic=true)]
+    public static class VersionAssertionExtensions
+    {
+        public static .<> IsMajorVersion(this ..IValueSource<> valueSource) { }
+        public static .<> IsNotMajorVersion(this ..IValueSource<> valueSource) { }
+    }
+    public class VersionVersionAssertionExtensionsIsMajorVersionWithVersionAssertCondition : .<>
+    {
+        public VersionVersionAssertionExtensionsIsMajorVersionWithVersionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<>("IsAlive")]
+    [.<>("IsAlive", CustomName="IsDead", NegateLogic=true)]
+    [.<>("TrackResurrection")]
+    [.<>("TrackResurrection", CustomName="DoesNotTrackResurrection", NegateLogic=true)]
+    public static class WeakReferenceAssertionExtensions
+    {
+        public static .<> DoesNotTrackResurrection(this ..IValueSource<> valueSource) { }
+        public static .<> IsAlive(this ..IValueSource<> valueSource) { }
+        public static .<> IsDead(this ..IValueSource<> valueSource) { }
+        public static .<> TrackResurrection(this ..IValueSource<> valueSource) { }
+    }
+    public class WeakReferenceIsAliveAssertCondition : .<>
+    {
+        public WeakReferenceIsAliveAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class WeakReferenceTrackResurrectionAssertCondition : .<>
+    {
+        public WeakReferenceTrackResurrectionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
     }
 }
 namespace .Helpers

From 3385ee138104ce103f4e99356956b66ac14d119f Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Tue, 30 Sep 2025 11:45:27 +0100
Subject: [PATCH 2/2] feat(AOT): add RequiresDynamicCode attributes to support
 dynamic tests in AOT scenarios

---
 TUnit.Core/DynamicTestBuilderContext.cs                    | 5 ++++-
 TUnit.Core/Extensions/TestContextExtensions.cs             | 1 +
 TUnit.Core/Interfaces/ITestRegistry.cs                     | 3 ++-
 TUnit.Engine/Building/Collectors/AotTestDataCollector.cs   | 5 +++++
 TUnit.Engine/Building/ReflectionMetadataBuilder.cs         | 7 -------
 TUnit.Engine/Services/TestRegistry.cs                      | 6 ++++++
 ....Core_Library_Has_No_API_Changes.DotNet8_0.verified.txt | 6 ++++++
 ....Core_Library_Has_No_API_Changes.DotNet9_0.verified.txt | 6 ++++++
 8 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/TUnit.Core/DynamicTestBuilderContext.cs b/TUnit.Core/DynamicTestBuilderContext.cs
index 25d5225fec..0c6c04bbbb 100644
--- a/TUnit.Core/DynamicTestBuilderContext.cs
+++ b/TUnit.Core/DynamicTestBuilderContext.cs
@@ -1,3 +1,5 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace TUnit.Core;
 
 /// <summary>
@@ -20,6 +22,7 @@ public DynamicTestBuilderContext(string filePath, int lineNumber)
 
     public IReadOnlyList<AbstractDynamicTest> Tests => _tests.AsReadOnly();
 
+    [RequiresDynamicCode("Adding dynamic tests requires reflection which is not supported in native AOT scenarios.")]
     public void AddTest(AbstractDynamicTest test)
     {
         // Set creator location if the test implements IDynamicTestCreatorLocation
@@ -28,7 +31,7 @@ public void AddTest(AbstractDynamicTest test)
             testWithLocation.CreatorFilePath = FilePath;
             testWithLocation.CreatorLineNumber = LineNumber;
         }
-        
+
         _tests.Add(test);
     }
 }
diff --git a/TUnit.Core/Extensions/TestContextExtensions.cs b/TUnit.Core/Extensions/TestContextExtensions.cs
index ba50b41e97..ffa127dfa0 100644
--- a/TUnit.Core/Extensions/TestContextExtensions.cs
+++ b/TUnit.Core/Extensions/TestContextExtensions.cs
@@ -24,6 +24,7 @@ public static string GetClassTypeName(this TestContext context)
         return $"{context.TestDetails.ClassType.Name}({string.Join(", ", context.TestDetails.TestClassArguments.Select(a => ArgumentFormatter.Format(a, context.ArgumentDisplayFormatters)))})";
     }
 
+    [RequiresDynamicCode("Adding dynamic tests requires reflection which is not supported in native AOT scenarios.")]
     public static async Task AddDynamicTest<[DynamicallyAccessedMembers(
         DynamicallyAccessedMemberTypes.PublicConstructors
         | DynamicallyAccessedMemberTypes.NonPublicConstructors
diff --git a/TUnit.Core/Interfaces/ITestRegistry.cs b/TUnit.Core/Interfaces/ITestRegistry.cs
index 51305ece09..f35120875e 100644
--- a/TUnit.Core/Interfaces/ITestRegistry.cs
+++ b/TUnit.Core/Interfaces/ITestRegistry.cs
@@ -14,6 +14,7 @@ public interface ITestRegistry
     /// <param name="context">The current test context</param>
     /// <param name="dynamicTest">The dynamic test instance to add</param>
     /// <returns>A task that completes when the test has been queued for execution</returns>
+    [RequiresDynamicCode("Adding dynamic tests requires runtime compilation and reflection which are not supported in native AOT scenarios.")]
     Task AddDynamicTest<[DynamicallyAccessedMembers(
         DynamicallyAccessedMemberTypes.PublicConstructors
         | DynamicallyAccessedMemberTypes.NonPublicConstructors
@@ -21,6 +22,6 @@ public interface ITestRegistry
         | DynamicallyAccessedMemberTypes.PublicMethods
         | DynamicallyAccessedMemberTypes.NonPublicMethods
         | DynamicallyAccessedMemberTypes.PublicFields
-        | DynamicallyAccessedMemberTypes.NonPublicFields)] T>(TestContext context, DynamicTest<T> dynamicTest) 
+        | DynamicallyAccessedMemberTypes.NonPublicFields)] T>(TestContext context, DynamicTest<T> dynamicTest)
         where T : class;
 }
\ No newline at end of file
diff --git a/TUnit.Engine/Building/Collectors/AotTestDataCollector.cs b/TUnit.Engine/Building/Collectors/AotTestDataCollector.cs
index 81c663447b..90aa7ad316 100644
--- a/TUnit.Engine/Building/Collectors/AotTestDataCollector.cs
+++ b/TUnit.Engine/Building/Collectors/AotTestDataCollector.cs
@@ -76,6 +76,8 @@ private async IAsyncEnumerable<TestMetadata> CollectDynamicTestsStreaming(
         }
     }
 
+    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.",
+        Justification = "Dynamic tests are opt-in and users are warned via RequiresDynamicCode on the method they call")]
     private async IAsyncEnumerable<TestMetadata> ConvertDynamicTestToMetadataStreaming(
         AbstractDynamicTest abstractDynamicTest,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
@@ -92,6 +94,7 @@ private async IAsyncEnumerable<TestMetadata> ConvertDynamicTestToMetadataStreami
         }
     }
 
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Dynamic tests require runtime compilation of lambda expressions and are not supported in native AOT scenarios.")]
     private Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(DynamicDiscoveryResult result)
     {
         if (result.TestClassType == null || result.TestMethod == null)
@@ -144,6 +147,7 @@ private Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(DynamicDisco
         });
     }
 
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Dynamic test instance creation requires Activator.CreateInstance and MakeGenericType which are not supported in native AOT scenarios.")]
     [UnconditionalSuppressMessage("Trimming",
         "IL2070:'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicConstructors' in call to 'System.Type.GetConstructors()'",
         Justification = "AOT mode uses source-generated factories")]
@@ -187,6 +191,7 @@ private Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(DynamicDisco
         };
     }
 
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Dynamic test invocation requires LambdaExpression.Compile() which is not supported in native AOT scenarios.")]
     private static Func<object, object?[], Task> CreateAotDynamicTestInvoker(DynamicDiscoveryResult result)
     {
         return async (instance, args) =>
diff --git a/TUnit.Engine/Building/ReflectionMetadataBuilder.cs b/TUnit.Engine/Building/ReflectionMetadataBuilder.cs
index f107b5e958..178c9f19f7 100644
--- a/TUnit.Engine/Building/ReflectionMetadataBuilder.cs
+++ b/TUnit.Engine/Building/ReflectionMetadataBuilder.cs
@@ -21,13 +21,6 @@ public static MethodMetadata CreateMethodMetadata(
             | DynamicallyAccessedMemberTypes.PublicProperties)] Type type,
         System.Reflection.MethodInfo method)
     {
-#if NET
-        if (!RuntimeFeature.IsDynamicCodeSupported)
-        {
-            throw new Exception("Using TUnit Reflection mechanisms isn't supported in AOT mode");
-        }
-#endif
-
         return new MethodMetadata
         {
             Name = method.Name,
diff --git a/TUnit.Engine/Services/TestRegistry.cs b/TUnit.Engine/Services/TestRegistry.cs
index a156a86e8a..14ffac453c 100644
--- a/TUnit.Engine/Services/TestRegistry.cs
+++ b/TUnit.Engine/Services/TestRegistry.cs
@@ -31,6 +31,7 @@ public TestRegistry(TestBuilderPipeline testBuilderPipeline,
         _sessionId = sessionId;
         _sessionCancellationToken = sessionCancellationToken;
     }
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Adding dynamic tests requires runtime compilation and reflection which are not supported in native AOT scenarios.")]
     public async Task AddDynamicTest<[DynamicallyAccessedMembers(
         DynamicallyAccessedMemberTypes.PublicConstructors
         | DynamicallyAccessedMemberTypes.NonPublicConstructors
@@ -64,6 +65,8 @@ public TestRegistry(TestBuilderPipeline testBuilderPipeline,
         await ProcessPendingDynamicTests();
     }
 
+    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.",
+        Justification = "Dynamic tests are opt-in and users are warned via RequiresDynamicCode on AddDynamicTest method")]
     private async Task ProcessPendingDynamicTests()
     {
         var testsToProcess = new List<PendingDynamicTest>();
@@ -100,6 +103,7 @@ private async Task ProcessPendingDynamicTests()
         }
     }
 
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Dynamic tests require runtime compilation of lambda expressions and are not supported in native AOT scenarios.")]
     private async Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(DynamicDiscoveryResult result)
     {
         if (result.TestClassType == null || result.TestMethod == null)
@@ -148,6 +152,7 @@ private async Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(Dynami
         });
     }
 
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Dynamic test instance creation requires Activator.CreateInstance which is not supported in native AOT scenarios.")]
     [UnconditionalSuppressMessage("Trimming",
         "IL2067:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call",
         Justification = "Dynamic tests require reflection")]
@@ -168,6 +173,7 @@ private async Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(Dynami
         };
     }
 
+    [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Dynamic test invocation requires LambdaExpression.Compile() which is not supported in native AOT scenarios.")]
     private static Func<object, object?[], Task> CreateRuntimeTestInvoker(DynamicDiscoveryResult result)
     {
         return async (instance, args) =>
diff --git a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index 2280fa4ab1..5603f7613a 100644
--- a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -646,6 +646,8 @@ namespace
         public string FilePath { get; }
         public int LineNumber { get; }
         public .<.AbstractDynamicTest> Tests { get; }
+        [.("Adding dynamic tests requires reflection which is not supported in native AOT sce" +
+            "narios.")]
         public void AddTest(.AbstractDynamicTest test) { }
     }
     public static class DynamicTestHelper
@@ -1925,6 +1927,8 @@ namespace .Extensions
     }
     public static class TestContextExtensions
     {
+        [.("Adding dynamic tests requires reflection which is not supported in native AOT sce" +
+            "narios.")]
         public static . AddDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T>(this .TestContext context, .DynamicTest<T> dynamicTest)
             where T :  class { }
         public static string GetClassTypeName(this .TestContext context) { }
@@ -2363,6 +2367,8 @@ namespace .Interfaces
     }
     public interface ITestRegistry
     {
+        [.("Adding dynamic tests requires runtime compilation and reflection which are not su" +
+            "pported in native AOT scenarios.")]
         . AddDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T>(.TestContext context, .DynamicTest<T> dynamicTest)
             where T :  class;
     }
diff --git a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index c8ad3f922b..6a6e6e9c70 100644
--- a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -646,6 +646,8 @@ namespace
         public string FilePath { get; }
         public int LineNumber { get; }
         public .<.AbstractDynamicTest> Tests { get; }
+        [.("Adding dynamic tests requires reflection which is not supported in native AOT sce" +
+            "narios.")]
         public void AddTest(.AbstractDynamicTest test) { }
     }
     public static class DynamicTestHelper
@@ -1925,6 +1927,8 @@ namespace .Extensions
     }
     public static class TestContextExtensions
     {
+        [.("Adding dynamic tests requires reflection which is not supported in native AOT sce" +
+            "narios.")]
         public static . AddDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T>(this .TestContext context, .DynamicTest<T> dynamicTest)
             where T :  class { }
         public static string GetClassTypeName(this .TestContext context) { }
@@ -2363,6 +2367,8 @@ namespace .Interfaces
     }
     public interface ITestRegistry
     {
+        [.("Adding dynamic tests requires runtime compilation and reflection which are not su" +
+            "pported in native AOT scenarios.")]
         . AddDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T>(.TestContext context, .DynamicTest<T> dynamicTest)
             where T :  class;
     }