diff --git a/.github/workflows/speed-comparison.yml b/.github/workflows/speed-comparison.yml
index c7a099133f..2cb395c098 100644
--- a/.github/workflows/speed-comparison.yml
+++ b/.github/workflows/speed-comparison.yml
@@ -26,30 +26,36 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v5
         with:
-          dotnet-version: 9.0.x
+          dotnet-version: 10.0.x
 
       - name: Build All Frameworks
         run: |
           dotnet build -c Release -p:TestFramework=TUNIT --framework net8.0
           dotnet build -c Release -p:TestFramework=TUNIT --framework net9.0
+          dotnet build -c Release -p:TestFramework=TUNIT --framework net10.0
           dotnet build -c Release -p:TestFramework=XUNIT --framework net8.0
           dotnet build -c Release -p:TestFramework=XUNIT --framework net9.0
+          dotnet build -c Release -p:TestFramework=XUNIT --framework net10.0
           dotnet build -c Release -p:TestFramework=XUNIT3 --framework net8.0
           dotnet build -c Release -p:TestFramework=XUNIT3 --framework net9.0
+          dotnet build -c Release -p:TestFramework=XUNIT3 --framework net10.0
           dotnet build -c Release -p:TestFramework=NUNIT --framework net8.0
           dotnet build -c Release -p:TestFramework=NUNIT --framework net9.0
+          dotnet build -c Release -p:TestFramework=NUNIT --framework net10.0
           dotnet build -c Release -p:TestFramework=MSTEST --framework net8.0
           dotnet build -c Release -p:TestFramework=MSTEST --framework net9.0
+          dotnet build -c Release -p:TestFramework=MSTEST --framework net10.0
         working-directory: "tools/speed-comparison/UnifiedTests"
 
       - name: Publish TUnit AOT
         run: |
           dotnet publish -c Release -p:TestFramework=TUNIT -p:Aot=true --framework net8.0 --runtime ${{ matrix.os == 'windows-latest' && 'win-x64' || matrix.os == 'ubuntu-latest' && 'linux-x64' || 'osx-arm64' }} --output bin/Release-TUNIT-AOT/net8.0
           dotnet publish -c Release -p:TestFramework=TUNIT -p:Aot=true --framework net9.0 --runtime ${{ matrix.os == 'windows-latest' && 'win-x64' || matrix.os == 'ubuntu-latest' && 'linux-x64' || 'osx-arm64' }} --output bin/Release-TUNIT-AOT/net9.0
+          dotnet publish -c Release -p:TestFramework=TUNIT -p:Aot=true --framework net10.0 --runtime ${{ matrix.os == 'windows-latest' && 'win-x64' || matrix.os == 'ubuntu-latest' && 'linux-x64' || 'osx-arm64' }} --output bin/Release-TUNIT-AOT/net10.0
         working-directory: "tools/speed-comparison/UnifiedTests"
 
       - name: Run Benchmark
-        run: dotnet run -c Release --framework net9.0 --allCategories=Runtime
+        run: dotnet run -c Release --framework net10.0 --allCategories=Runtime
         working-directory: "tools/speed-comparison/Tests.Benchmark"
         env:
           CLASS_NAME: ${{ matrix.class }}
@@ -83,7 +89,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v5
         with:
-          dotnet-version: 9.0.x
+          dotnet-version: 10.0.x
 
       - name: Prepare builds
         run: |
@@ -91,7 +97,7 @@ jobs:
         working-directory: "tools/speed-comparison"
 
       - name: Run Benchmark
-        run: dotnet run -c Release --allCategories=Build --framework net9.0
+        run: dotnet run -c Release --allCategories=Build --framework net10.0
         working-directory: "tools/speed-comparison/Tests.Benchmark"
 
       - name: Upload Markdown
diff --git a/Directory.Build.props b/Directory.Build.props
index 750a8ab0e7..a351596691 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup Condition="'$(TargetFramework)' == '' and '$(TargetFrameworks)' == ''">
-    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/Directory.Packages.props b/Directory.Packages.props
index e7f6c51c8b..811b94240d 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -13,7 +13,7 @@
     <PackageVersion Include="CliWrap" Version="3.9.0" />
     <PackageVersion Include="EnumerableAsyncProcessor" Version="3.8.4" />
     <PackageVersion Include="FluentValidation.DependencyInjectionExtensions" Version="12.0.0" />
-    <PackageVersion Include="FSharp.Core" Version="9.0.303" />
+    <PackageVersion Include="FSharp.Core" Version="10.0.100-preview7.25451.107" />
     <PackageVersion Include="Humanizer" Version="2.14.1" />
     <PackageVersion Include="MessagePack" Version="3.1.4" />
     <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.0.9" />
diff --git a/Library.props b/Library.props
index c3e8636f73..f05d61c64a 100644
--- a/Library.props
+++ b/Library.props
@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup>
-        <TargetFrameworks>netstandard2.0;net8.0;net9.0</TargetFrameworks>
+        <TargetFrameworks>netstandard2.0;net8.0;net9.0;net10.0</TargetFrameworks>
 
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
 
diff --git a/TUnit.Analyzers.Tests/TUnit.Analyzers.Tests.csproj b/TUnit.Analyzers.Tests/TUnit.Analyzers.Tests.csproj
index 06c1129015..1a56243f60 100644
--- a/TUnit.Analyzers.Tests/TUnit.Analyzers.Tests.csproj
+++ b/TUnit.Analyzers.Tests/TUnit.Analyzers.Tests.csproj
@@ -28,5 +28,11 @@
     <Reference Include="$(PkgMicrosoft_CodeAnalysis_NetAnalyzers)\analyzers\dotnet\cs\Microsoft.CodeAnalysis.CSharp.NetAnalyzers.dll" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" VersionOverride="9.0.0" PrivateAssets="all" GeneratePathProperty="true" />
+    <Reference Include="$(PkgMicrosoft_CodeAnalysis_NetAnalyzers)\analyzers\dotnet\cs\Microsoft.CodeAnalysis.NetAnalyzers.dll" />
+    <Reference Include="$(PkgMicrosoft_CodeAnalysis_NetAnalyzers)\analyzers\dotnet\cs\Microsoft.CodeAnalysis.CSharp.NetAnalyzers.dll" />
+  </ItemGroup>
+
   <Import Project="..\TestProject.targets" />
 </Project>
diff --git a/TUnit.Core.SourceGenerator.Tests/AssemblyLoaderTests.Test.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/AssemblyLoaderTests.Test.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..5f18b8ee5b
--- /dev/null
+++ b/TUnit.Core.SourceGenerator.Tests/AssemblyLoaderTests.Test.DotNet10_0.verified.txt
@@ -0,0 +1,234 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_SynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "SynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "SynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 5,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "SynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                instance.SynchronousTest();
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_SynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_SynchronousTest_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_AsynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "AsynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "AsynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 11,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "AsynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.AsynchronousTest();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_AsynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_AsynchronousTest_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_ValueTaskAsynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "ValueTaskAsynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "ValueTaskAsynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 17,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "ValueTaskAsynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.ValueTask),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.ValueTask, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.ValueTaskAsynchronousTest();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_ValueTaskAsynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_ValueTaskAsynchronousTest_TestSource_GUID());
+    }
+}
diff --git a/TUnit.Core.SourceGenerator.Tests/BasicTests.Test.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/BasicTests.Test.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..5f18b8ee5b
--- /dev/null
+++ b/TUnit.Core.SourceGenerator.Tests/BasicTests.Test.DotNet10_0.verified.txt
@@ -0,0 +1,234 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_SynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "SynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "SynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 5,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "SynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                instance.SynchronousTest();
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_SynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_SynchronousTest_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_AsynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "AsynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "AsynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 11,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "AsynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.AsynchronousTest();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_AsynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_AsynchronousTest_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_ValueTaskAsynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "ValueTaskAsynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "ValueTaskAsynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 17,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "ValueTaskAsynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.ValueTask),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.ValueTask, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.ValueTaskAsynchronousTest();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_ValueTaskAsynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_ValueTaskAsynchronousTest_TestSource_GUID());
+    }
+}
diff --git a/TUnit.Core.SourceGenerator.Tests/Bugs2971NullableTypeTest.Test.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/Bugs2971NullableTypeTest.Test.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..e5d849e14d
--- /dev/null
+++ b/TUnit.Core.SourceGenerator.Tests/Bugs2971NullableTypeTest.Test.DotNet10_0.verified.txt
@@ -0,0 +1,77 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class Tests_SimpleTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.Bugs._2971.Tests>
+        {
+            TestName = "SimpleTest",
+            TestClassType = typeof(global::TUnit.TestProject.Bugs._2971.Tests),
+            TestMethodName = "SimpleTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.TestProject.Bugs._2971.SomeAttribute(typeof(global::System.Nullable<>))
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 19,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.Bugs._2971.Tests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.Bugs._2971.Tests, TestsBase`1"),
+                Name = "SimpleTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._2971.Tests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.Bugs._2971.Tests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.Bugs._2971.Tests, TestsBase`1"),
+                        Name = "Tests",
+                        Namespace = "TUnit.TestProject.Bugs._2971",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.Bugs._2971.Tests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                instance.SimpleTest();
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class Tests_SimpleTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.Bugs._2971.Tests), new Tests_SimpleTest_TestSource_GUID());
+    }
+}
diff --git a/TUnit.Core.SourceGenerator.Tests/DisableReflectionScannerTests.Test.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/DisableReflectionScannerTests.Test.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..5f18b8ee5b
--- /dev/null
+++ b/TUnit.Core.SourceGenerator.Tests/DisableReflectionScannerTests.Test.DotNet10_0.verified.txt
@@ -0,0 +1,234 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_SynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "SynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "SynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 5,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "SynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                instance.SynchronousTest();
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_SynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_SynchronousTest_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_AsynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "AsynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "AsynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 11,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "AsynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.AsynchronousTest();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_AsynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_AsynchronousTest_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class BasicTests_ValueTaskAsynchronousTest_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.BasicTests>
+        {
+            TestName = "ValueTaskAsynchronousTest",
+            TestClassType = typeof(global::TUnit.TestProject.BasicTests),
+            TestMethodName = "ValueTaskAsynchronousTest",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 17,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.BasicTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                Name = "ValueTaskAsynchronousTest",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.ValueTask),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.ValueTask, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.BasicTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.BasicTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.BasicTests, TestsBase`1"),
+                        Name = "BasicTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.BasicTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.ValueTaskAsynchronousTest();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class BasicTests_ValueTaskAsynchronousTest_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.BasicTests), new BasicTests_ValueTaskAsynchronousTest_TestSource_GUID());
+    }
+}
diff --git a/TUnit.Core.SourceGenerator.Tests/STAThreadTests.Test.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/STAThreadTests.Test.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..e7de14ae1d
--- /dev/null
+++ b/TUnit.Core.SourceGenerator.Tests/STAThreadTests.Test.DotNet10_0.verified.txt
@@ -0,0 +1,1087 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_With_STA_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "With_STA",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "With_STA",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 14,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "With_STA",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.With_STA();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_With_STA_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_With_STA_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_Without_STA_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "Without_STA",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "Without_STA",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 20,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "Without_STA",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.Without_STA();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_Without_STA_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_Without_STA_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithSimpleAwait_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithSimpleAwait",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithSimpleAwait",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 26,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithSimpleAwait",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithSimpleAwait();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithSimpleAwait_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithSimpleAwait_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithTaskYield_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithTaskYield",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithTaskYield",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 36,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithTaskYield",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithTaskYield();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithTaskYield_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithTaskYield_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithConfigureAwaitTrue_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithConfigureAwaitTrue",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithConfigureAwaitTrue",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 45,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithConfigureAwaitTrue",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithConfigureAwaitTrue();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithConfigureAwaitTrue_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithConfigureAwaitTrue_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithNestedAsyncCalls_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithNestedAsyncCalls",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithNestedAsyncCalls",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 54,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithNestedAsyncCalls",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithNestedAsyncCalls();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithNestedAsyncCalls_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithNestedAsyncCalls_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithTaskFromResult_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithTaskFromResult",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithTaskFromResult",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 64,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithTaskFromResult",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithTaskFromResult();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithTaskFromResult_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithTaskFromResult_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithCompletedTask_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithCompletedTask",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithCompletedTask",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 74,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithCompletedTask",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithCompletedTask();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithCompletedTask_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithCompletedTask_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithTaskRun_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithTaskRun",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithTaskRun",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 83,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithTaskRun",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithTaskRun();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithTaskRun_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithTaskRun_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithMultipleAwaits_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithMultipleAwaits",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithMultipleAwaits",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 98,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithMultipleAwaits",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithMultipleAwaits();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithMultipleAwaits_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithMultipleAwaits_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithAsyncEnumerable_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithAsyncEnumerable",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithAsyncEnumerable",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 116,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithAsyncEnumerable",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithAsyncEnumerable();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithAsyncEnumerable_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithAsyncEnumerable_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithTaskWhenAll_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithTaskWhenAll",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithTaskWhenAll",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 130,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithTaskWhenAll",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithTaskWhenAll();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithTaskWhenAll_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithTaskWhenAll_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class STAThreadTests_STA_WithExceptionHandling_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.STAThreadTests>
+        {
+            TestName = "STA_WithExceptionHandling",
+            TestClassType = typeof(global::TUnit.TestProject.STAThreadTests),
+            TestMethodName = "STA_WithExceptionHandling",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.Core.Executors.STAThreadExecutorAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.RunOnAttribute(global::TUnit.Core.Enums.OS.Windows),
+                new global::TUnit.Core.RepeatAttribute(100),
+                new global::System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Interoperability", "CA1416:Validate platform compatibility")
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 0,
+            FilePath = @"",
+            LineNumber = 147,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                Name = "STA_WithExceptionHandling",
+                GenericTypeCount = 0,
+                ReturnType = typeof(global::System.Threading.Tasks.Task),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("System.Threading.Tasks.Task, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.STAThreadTests", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.STAThreadTests),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.STAThreadTests, TestsBase`1"),
+                        Name = "STAThreadTests",
+                        Namespace = "TUnit.TestProject",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.STAThreadTests(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                await instance.STA_WithExceptionHandling();
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class STAThreadTests_STA_WithExceptionHandling_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.STAThreadTests), new STAThreadTests_STA_WithExceptionHandling_TestSource_GUID());
+    }
+}
diff --git a/TUnit.Core.SourceGenerator.Tests/Tests1889.Test.DotNet10_0.verified.txt b/TUnit.Core.SourceGenerator.Tests/Tests1889.Test.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..24350fc30c
--- /dev/null
+++ b/TUnit.Core.SourceGenerator.Tests/Tests1889.Test.DotNet10_0.verified.txt
@@ -0,0 +1,281 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class DerivedTest_Test1_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.Bugs._1889.DerivedTest>
+        {
+            TestName = "Test1",
+            TestClassType = typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest),
+            TestMethodName = "Test1",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.InheritsTestsAttribute()
+            ],
+            DataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 1,
+            FilePath = @"",
+            LineNumber = 6,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.Library.Bugs._1889.BaseTest<DummyReferenceTypeClass>),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConstructedGeneric("TUnit.TestProject.Library.Bugs._1889.BaseTest<>, TestsBase`1", global::TUnit.Core.TypeReference.CreateConcrete("DummyReferenceTypeClass, TestsBase`1")),
+                Name = "Test1",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._1889.DerivedTest", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.Bugs._1889.DerivedTest, TestsBase`1"),
+                        Name = "DerivedTest",
+                        Namespace = "TUnit.TestProject.Bugs._1889",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.Bugs._1889.DerivedTest(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                instance.Test1();
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class DerivedTest_Test1_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest), new DerivedTest_Test1_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class DerivedTest_Test2_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.Bugs._1889.DerivedTest>
+        {
+            TestName = "Test2",
+            TestClassType = typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest),
+            TestMethodName = "Test2",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.InheritsTestsAttribute()
+            ],
+            DataSources = new global::TUnit.Core.IDataSourceAttribute[]
+            {
+                new global::TUnit.Core.MatrixDataSourceAttribute(),
+            },
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 1,
+            FilePath = @"",
+            LineNumber = 6,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.Library.Bugs._1889.BaseTest<DummyReferenceTypeClass>),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConstructedGeneric("TUnit.TestProject.Library.Bugs._1889.BaseTest<>, TestsBase`1", global::TUnit.Core.TypeReference.CreateConcrete("DummyReferenceTypeClass, TestsBase`1")),
+                Name = "Test2",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = new global::TUnit.Core.ParameterMetadata[]
+                {
+                    new global::TUnit.Core.ParameterMetadata(typeof(bool))
+                    {
+                        Name = "condition",
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("bool, System.Private.CoreLib"),
+                        IsNullable = false,
+                        ReflectionInfo = typeof(global::TUnit.TestProject.Library.Bugs._1889.BaseTest<DummyReferenceTypeClass>).GetMethod("Test2", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(bool) }, null)!.GetParameters()[0]
+                    }
+                },
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._1889.DerivedTest", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.Bugs._1889.DerivedTest, TestsBase`1"),
+                        Name = "DerivedTest",
+                        Namespace = "TUnit.TestProject.Bugs._1889",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.Bugs._1889.DerivedTest(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                switch (args.Length)
+                {
+                    case 1:
+                        instance.Test2(TUnit.Core.Helpers.CastHelper.Cast<bool>(args[0]));
+                        break;
+                    default:
+                        throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}");
+                }
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class DerivedTest_Test2_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest), new DerivedTest_Test2_TestSource_GUID());
+    }
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+internal sealed class DerivedTest_Test3_TestSource_GUID : global::TUnit.Core.Interfaces.SourceGenerator.ITestSource
+{
+    public async global::System.Collections.Generic.IAsyncEnumerable<global::TUnit.Core.TestMetadata> GetTestsAsync(string testSessionId, [global::System.Runtime.CompilerServices.EnumeratorCancellation] global::System.Threading.CancellationToken cancellationToken = default)
+    {
+        var metadata = new global::TUnit.Core.TestMetadata<global::TUnit.TestProject.Bugs._1889.DerivedTest>
+        {
+            TestName = "Test3",
+            TestClassType = typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest),
+            TestMethodName = "Test3",
+            Dependencies = global::System.Array.Empty<global::TUnit.Core.TestDependency>(),
+            AttributeFactory = () =>
+            [
+                new global::TUnit.Core.TestAttribute(),
+                new global::TUnit.TestProject.Attributes.EngineTest(global::TUnit.TestProject.Attributes.ExpectedResult.Pass),
+                new global::TUnit.Core.InheritsTestsAttribute()
+            ],
+            DataSources = new global::TUnit.Core.IDataSourceAttribute[]
+            {
+                new global::TUnit.Core.ArgumentsAttribute(false),
+                new global::TUnit.Core.ArgumentsAttribute(true),
+            },
+            ClassDataSources = global::System.Array.Empty<global::TUnit.Core.IDataSourceAttribute>(),
+            PropertyDataSources = global::System.Array.Empty<global::TUnit.Core.PropertyDataSource>(),
+            PropertyInjections = global::System.Array.Empty<global::TUnit.Core.PropertyInjectionData>(),
+            InheritanceDepth = 1,
+            FilePath = @"",
+            LineNumber = 6,
+            MethodMetadata = new global::TUnit.Core.MethodMetadata
+            {
+                Type = typeof(global::TUnit.TestProject.Library.Bugs._1889.BaseTest<DummyReferenceTypeClass>),
+                TypeReference = global::TUnit.Core.TypeReference.CreateConstructedGeneric("TUnit.TestProject.Library.Bugs._1889.BaseTest<>, TestsBase`1", global::TUnit.Core.TypeReference.CreateConcrete("DummyReferenceTypeClass, TestsBase`1")),
+                Name = "Test3",
+                GenericTypeCount = 0,
+                ReturnType = typeof(void),
+                ReturnTypeReference = global::TUnit.Core.TypeReference.CreateConcrete("void, System.Private.CoreLib"),
+                Parameters = new global::TUnit.Core.ParameterMetadata[]
+                {
+                    new global::TUnit.Core.ParameterMetadata(typeof(bool))
+                    {
+                        Name = "condition",
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("bool, System.Private.CoreLib"),
+                        IsNullable = false,
+                        ReflectionInfo = typeof(global::TUnit.TestProject.Library.Bugs._1889.BaseTest<DummyReferenceTypeClass>).GetMethod("Test3", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.Instance, null, new global::System.Type[] { typeof(bool) }, null)!.GetParameters()[0]
+                    }
+                },
+                Class = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._1889.DerivedTest", () => 
+                {
+                    var classMetadata = new global::TUnit.Core.ClassMetadata
+                    {
+                        Type = typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest),
+                        TypeReference = global::TUnit.Core.TypeReference.CreateConcrete("TUnit.TestProject.Bugs._1889.DerivedTest, TestsBase`1"),
+                        Name = "DerivedTest",
+                        Namespace = "TUnit.TestProject.Bugs._1889",
+                        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", () => new global::TUnit.Core.AssemblyMetadata { Name = "TestsBase`1" }),
+                        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+                        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+                        Parent = null
+                    };
+                    foreach (var prop in classMetadata.Properties)
+                    {
+                        prop.ClassMetadata = classMetadata;
+                        prop.ContainingTypeMetadata = classMetadata;
+                    }
+                    return classMetadata;
+                })
+            },
+            InstanceFactory = (typeArgs, args) => new global::TUnit.TestProject.Bugs._1889.DerivedTest(),
+            InvokeTypedTest = async (instance, args, cancellationToken) =>
+            {
+                switch (args.Length)
+                {
+                    case 1:
+                        instance.Test3(TUnit.Core.Helpers.CastHelper.Cast<bool>(args[0]));
+                        break;
+                    default:
+                        throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}");
+                }
+                await global::System.Threading.Tasks.Task.CompletedTask;
+            },
+        };
+        metadata.UseRuntimeDataGeneration(testSessionId);
+        yield return metadata;
+        yield break;
+    }
+}
+internal static class DerivedTest_Test3_ModuleInitializer_GUID
+{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void Initialize()
+    {
+        global::TUnit.Core.SourceRegistrar.Register(typeof(global::TUnit.TestProject.Bugs._1889.DerivedTest), new DerivedTest_Test3_TestSource_GUID());
+    }
+}
diff --git a/TUnit.Engine.Tests/FSharp.cs b/TUnit.Engine.Tests/FSharp.cs
index b3e2ebe26f..068f714cfb 100644
--- a/TUnit.Engine.Tests/FSharp.cs
+++ b/TUnit.Engine.Tests/FSharp.cs
@@ -20,7 +20,7 @@ public async Task Test()
                 [
                     "run",
                     "--no-build",
-                    "-f", "net9.0",
+                    "-f", "net10.0",
                     "--configuration", "Release",
                     "--report-trx", "--report-trx-filename", trxFilename,
                     "--diagnostic-verbosity", "Debug",
diff --git a/TUnit.Engine.Tests/InvokableTestBase.cs b/TUnit.Engine.Tests/InvokableTestBase.cs
index d3768d176c..7b052d81d1 100644
--- a/TUnit.Engine.Tests/InvokableTestBase.cs
+++ b/TUnit.Engine.Tests/InvokableTestBase.cs
@@ -174,7 +174,7 @@ private async Task RunWithFailureLogging(Command command, string trxFilename, Li
                                  @$"Output: {commandResult?.StandardOutput}"
 
                                  Expression: {assertionExpression}
-                                 """, e);
+                                 """);
         }
     }
 }
diff --git a/TUnit.Engine.Tests/VB.cs b/TUnit.Engine.Tests/VB.cs
index 072774c3bd..55cf5e78d6 100644
--- a/TUnit.Engine.Tests/VB.cs
+++ b/TUnit.Engine.Tests/VB.cs
@@ -20,7 +20,7 @@ public async Task Test()
                 [
                     "run",
                     "--no-build",
-                    "-f", "net9.0",
+                    "-f", "net10.0",
                     "--configuration", "Release",
                     "--report-trx", "--report-trx-filename", trxFilename,
                     "--diagnostic-verbosity", "Debug",
diff --git a/TUnit.Example.Asp.Net.TestProject/TUnit.Example.Asp.Net.TestProject.csproj b/TUnit.Example.Asp.Net.TestProject/TUnit.Example.Asp.Net.TestProject.csproj
index 8e8c7c93a6..4106a2cedb 100644
--- a/TUnit.Example.Asp.Net.TestProject/TUnit.Example.Asp.Net.TestProject.csproj
+++ b/TUnit.Example.Asp.Net.TestProject/TUnit.Example.Asp.Net.TestProject.csproj
@@ -3,7 +3,7 @@
     <Import Project="..\TestProject.props" />
     
     <PropertyGroup>
-        <TargetFrameworks>net9.0</TargetFrameworks>
+        <TargetFrameworks>net9.0;net10.0</TargetFrameworks>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/TUnit.Example.Asp.Net/TUnit.Example.Asp.Net.csproj b/TUnit.Example.Asp.Net/TUnit.Example.Asp.Net.csproj
index e69a194497..69d9f6d009 100644
--- a/TUnit.Example.Asp.Net/TUnit.Example.Asp.Net.csproj
+++ b/TUnit.Example.Asp.Net/TUnit.Example.Asp.Net.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
-        <TargetFrameworks>net9.0</TargetFrameworks>
+        <TargetFrameworks>net9.0;net10.0</TargetFrameworks>
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <IsPackable>false</IsPackable>
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..8ed4adcd04
--- /dev/null
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -0,0 +1,3196 @@
+[assembly: .(".NETCoreApp,Version=v10.0", FrameworkDisplayName=".NET 10.0")]
+namespace 
+{
+    [.("Usage", "TUnitAssertions0002:Assert statements must be awaited")]
+    public static class Assert
+    {
+        public static void Fail(string reason) { }
+        public static  Multiple() { }
+        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  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 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>
+    {
+        public AssertionData(object? Result, ? Exception, string? ActualExpression,  Start,  End) { }
+        public string? ActualExpression { get; init; }
+        public  End { get; init; }
+        public ? Exception { get; init; }
+        public object? Result { get; init; }
+        public  Start { get; init; }
+        public static .AssertionData op_Implicit(<object?, ?, string?, , > tuple) { }
+    }
+    public class AssertionDecision : <.AssertionDecision>
+    {
+        public static .AssertionDecision Continue { get; }
+        public static .AssertionDecision Pass { get; }
+        public static .AssertionDecision Fail(string message) { }
+    }
+    public class AssertionMetadata
+    {
+        public AssertionMetadata() { }
+        public  Duration { get; }
+        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 = "") { }
+    }
+    [.("Trimming", "IL2075", Justification="AOT mode uses the attributed compiler type instead of the runtime GetType.")]
+    public static class Compare
+    {
+        public static .<.ComparisonFailure> CheckEquivalent<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  TActual, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  TExpected>(TActual actual, TExpected expected, .CompareOptions options, int? index) { }
+    }
+    public class CompareOptions : <.CompareOptions>
+    {
+        public CompareOptions() { }
+        public . EquivalencyKind { get; set; }
+        public string[] MembersToIgnore { get; init; }
+        public [] TypesToIgnore { get; init; }
+    }
+    public class ComparisonFailure : <.ComparisonFailure>
+    {
+        public ComparisonFailure() { }
+        public required object? Actual { get; init; }
+        public required object? Expected { get; init; }
+        public required string[] NestedMemberNames { get; init; }
+        public required .MemberType Type { get; init; }
+    }
+    public static class Fail
+    {
+        [.]
+        public static void Test(string reason) { }
+        public static void Unless([.(false)] bool condition, string reason) { }
+        public static void When([.(true)] bool condition, string reason) { }
+    }
+    public abstract class LazyAssertionData
+    {
+        protected abstract .<.AssertionData> EvaluateAsync();
+        public .<.AssertionData> GetResultAsync() { }
+        public .LazyAssertionData WithConversion<TFromType, TToType>(..IValueSource<TFromType> valueSource, .<TFromType, TToType> convertToAssertCondition) { }
+        public .LazyAssertionData WithExceptionAsValue<TException>(..IDelegateSource delegateSource, ..<TException> convertToAssertCondition)
+            where TException :  { }
+        public static .LazyAssertionData Create( action, string? actualExpression) { }
+        public static .LazyAssertionData Create(<.> action, string? actualExpression) { }
+        public static .LazyAssertionData Create<T>(<.<T>> func, string? actualExpression) { }
+        public static .LazyAssertionData Create<T>(<T> func, string? actualExpression) { }
+        public static .LazyAssertionData Create<T>(T value, string? actualExpression) { }
+    }
+    public enum MemberType
+    {
+        Property = 0,
+        Field = 1,
+        Value = 2,
+        EnumerableItem = 3,
+        DictionaryItem = 4,
+    }
+}
+namespace .AssertConditions
+{
+    public class AssertionResult
+    {
+        public bool IsPassed { get; }
+        public string Message { get; }
+        public static . Passed { get; }
+        public . And(. other) { }
+        public .<.> OrAsync(<.<.>> otherResult) { }
+        public . OrFailIf(bool isFailed, [.("isFailed")] ..InterpolatedStringHandler stringHandler) { }
+        public . OrFailIf(bool isFailed, string message) { }
+        public static . Fail(string message) { }
+        public static . FailIf(bool isFailed, [.("isFailed")] ..InterpolatedStringHandler stringHandler) { }
+        public static . FailIf(bool isFailed, string message) { }
+        public static .<.> op_Implicit(. result) { }
+        public static .<.> op_Implicit(. result) { }
+        [.]
+        public readonly struct InterpolatedStringHandler
+        {
+            public InterpolatedStringHandler(int literalLength, int formattedCount, bool isFailed, out bool enabled) { }
+            public void AppendFormatted<T>(T? t) { }
+            public void AppendFormatted<T>(T? t, string format)
+                where T :  { }
+            public void AppendLiteral(string s) { }
+        }
+    }
+    public abstract class BaseAssertCondition
+    {
+        protected BaseAssertCondition() { }
+        public string? OverriddenMessage { get; }
+        public string? Subject { get; }
+        public virtual ? WaitFor { get; protected set; }
+        public . FailWithMessage(string message) { }
+        protected abstract string GetExpectation();
+    }
+    public abstract class BaseAssertCondition<TActual> : .
+    {
+        protected BaseAssertCondition() { }
+        public string? ActualExpression { get; }
+        public .<.> GetAssertionResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata, string? actualExpression = null) { }
+        protected abstract .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata);
+    }
+    public enum ChainType
+    {
+        None = 0,
+        And = 1,
+        Or = 2,
+    }
+    public abstract class ConvertToAssertCondition<TFromType, TToType> : .<TFromType>
+    {
+        protected ConvertToAssertCondition() { }
+        public TToType ConvertedValue { get; }
+        public abstract .<<., TToType?>> ConvertValue(TFromType? value);
+        protected override sealed .<.> GetResult(TFromType? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public abstract class DelegateAssertCondition : .<object?, >
+    {
+        protected DelegateAssertCondition() { }
+    }
+    public abstract class DelegateAssertCondition<TActual> : .<TActual, >
+    {
+        protected DelegateAssertCondition() { }
+    }
+    public abstract class DelegateAssertCondition<TActual, TException> : .<TActual>
+        where TException : 
+    {
+        protected DelegateAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected virtual string GetFailureMessage(TException? exception) { }
+        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() { }
+    }
+    public abstract class ExpectedValueAssertCondition<TActual, TExpected> : .<TActual>
+    {
+        protected ExpectedValueAssertCondition(TExpected? expected) { }
+        public TExpected ExpectedValue { get; }
+        protected abstract .<.> GetResult(TActual? actualValue, TExpected? expectedValue);
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+        public void WithComparer(<TActual?, TExpected?, .AssertionDecision> comparer) { }
+        public void WithTransform(<TActual?, TActual?> actualTransformation, <TExpected?, TExpected?> expectedTransformation) { }
+    }
+    public class FailureLocation : <.>
+    {
+        public FailureLocation() { }
+        public object? ActualValue { get; }
+        public object? ExpectedValue { get; }
+        public long Position { get; }
+    }
+    public class FuncValueAssertCondition<TActual, TExpected> : .<TActual, TExpected>
+    {
+        public FuncValueAssertCondition(TExpected? expected, <TActual?, TExpected?, .<TActual, TExpected>, bool> condition, <TActual?, ?, string?, string> defaultMessageFactory, string expectation) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TActual? actualValue, TExpected? expectedValue) { }
+    }
+    public class NotNullExpectedValueAssertCondition<TActual> : .<TActual?, TActual>
+        where TActual :  class?
+    {
+        public NotNullExpectedValueAssertCondition() { }
+        public override .<<., TActual?>> ConvertValue(TActual? value) { }
+        protected override string GetExpectation() { }
+    }
+    public class NotNullStructExpectedValueAssertCondition<TActual> : .<TActual?, TActual>
+        where TActual :  struct
+    {
+        public NotNullStructExpectedValueAssertCondition() { }
+        public override .<<., TActual>> ConvertValue(TActual? value) { }
+        protected override string GetExpectation() { }
+    }
+    public class NullExpectedValueAssertCondition<TActual> : .<TActual>
+    {
+        public NullExpectedValueAssertCondition() { }
+        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) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(T? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public abstract class StringMatcher
+    {
+        protected StringMatcher() { }
+        public static ..RegexMatch AsRegex([.("regex")] string pattern) { }
+        public static ..WildcardMatch AsWildcard(string pattern) { }
+        public static . op_Implicit(. pattern) { }
+        public static . op_Implicit(string pattern) { }
+        public sealed class RegexMatch : .
+        {
+            public ..RegexMatch IgnoringCase(bool ignoreCase = true) { }
+            public override string ToString() { }
+        }
+        public sealed class WildcardMatch : .
+        {
+            public ..WildcardMatch IgnoringCase(bool ignoreCase = true) { }
+            public override string ToString() { }
+        }
+    }
+    public abstract class ValueAssertCondition<TActual> : .<TActual>
+    {
+        protected ValueAssertCondition() { }
+        protected override string GetExpectation() { }
+        protected abstract string GetFailureMessage(TActual? actualValue);
+        protected override .<.> GetResult(TActual? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+        protected abstract . Passes(TActual? actualValue);
+        public void WithComparer(<TActual?, .AssertionDecision> comparer) { }
+        public void WithTransform(<TActual?, TActual?> actualTransformation) { }
+    }
+}
+namespace .
+{
+    public class DateOnlyEqualsExpectedValueAssertCondition : .<, >
+    {
+        public DateOnlyEqualsExpectedValueAssertCondition( expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult( actualValue,  expectedValue) { }
+        public void SetTolerance(int toleranceDays) { }
+    }
+    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 TimeOnlyEqualsExpectedValueAssertCondition : .<, >
+    {
+        public TimeOnlyEqualsExpectedValueAssertCondition( 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) { }
+        [.("Expression compilation requires dynamic code generation")]
+        [.("Expression compilation requires unreferenced code")]
+        public .<TActualRootType> EqualTo(TPropertyType expected, [.("expected")] string? doNotPopulateThisValue = null) { }
+        [.("Expression compilation requires dynamic code generation")]
+        [.("Expression compilation requires unreferenced code")]
+        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 : 
+    {
+        public ExceptionMessageContainingExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TException? actualValue, string? expectedValue) { }
+    }
+    public class ExceptionMessageEndingWithExpectedValueAssertCondition<TException> : .<TException, string>
+        where TException : 
+    {
+        public ExceptionMessageEndingWithExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TException? actualValue, string? expectedValue) { }
+    }
+    public class ExceptionMessageEqualsExpectedValueAssertCondition<TException> : .<TException, string>
+        where TException : 
+    {
+        public ExceptionMessageEqualsExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TException? actualValue, string? expectedValue) { }
+    }
+    public class ExceptionMessageMatchingExpectedAssertCondition<TException> : .<TException, .>
+        where TException : 
+    {
+        public ExceptionMessageMatchingExpectedAssertCondition(. match) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TException? actualValue, .? expectedValue) { }
+    }
+    public class ExceptionMessageStartingWithExpectedValueAssertCondition<TException> : .<TException, string>
+        where TException : 
+    {
+        public ExceptionMessageStartingWithExpectedValueAssertCondition(string expected,  stringComparison) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TException? actualValue, string? expectedValue) { }
+    }
+}
+namespace .
+{
+    public class ConvertedDelegateSource<TToType> : ..ISource, ..IValueSource<TToType?>
+        where TToType : 
+    {
+        public ConvertedDelegateSource(..IDelegateSource source) { }
+        public string? ActualExpression { get; }
+        public .<.> Assertions { get; }
+        public .StringBuilder ExpressionBuilder { get; }
+        public .LazyAssertionData LazyAssertionData { 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 .<.> Assertions { get; }
+        public .StringBuilder ExpressionBuilder { get; }
+        public .LazyAssertionData LazyAssertionData { get; }
+        public ..ISource AppendExpression(string expression) { }
+        public ..ISource WithAssertion(. assertCondition) { }
+    }
+    public interface IDelegateSource : ..ISource { }
+    public interface ISource
+    {
+        string? ActualExpression { get; }
+        ..ISource AppendExpression(string expression);
+        ..ISource WithAssertion(. assertCondition);
+    }
+    public interface IValueDelegateSource<out TActual> : ..IDelegateSource, ..ISource, ..IValueSource<TActual> { }
+    public interface IValueSource<out TActual> : ..ISource { }
+}
+namespace .
+{
+    []
+    public enum AssertionType
+    {
+        Value = 1,
+        Delegate = 2,
+    }
+    public class DelegateAnd<TActual> : ..IDelegateSource, ..ISource
+    {
+        public DelegateAnd(. assertionBuilder) { }
+        public static ..DelegateAnd<TActual> Create(. assertionBuilder) { }
+    }
+    public class DelegateOr<TActual> : ..IDelegateSource, ..ISource
+    {
+        public DelegateOr(. assertionBuilder) { }
+        public static ..DelegateOr<TActual> Create(. assertionBuilder) { }
+    }
+    public class ValueAnd<TActual> : ..ISource, ..IValueSource<TActual>
+    {
+        public ValueAnd(. assertionBuilder) { }
+        public static ..ValueAnd<TActual> Create(. assertionBuilder) { }
+    }
+    public class ValueDelegateAnd<TActual> : ..IDelegateSource, ..ISource, ..IValueDelegateSource<TActual>, ..IValueSource<TActual>
+    {
+        public ValueDelegateAnd(. assertionBuilder) { }
+        public static ..ValueDelegateAnd<TActual> Create(. assertionBuilder) { }
+    }
+    public class ValueDelegateOr<TActual> : ..IDelegateSource, ..ISource, ..IValueDelegateSource<TActual>, ..IValueSource<TActual>
+    {
+        public ValueDelegateOr(. assertionBuilder) { }
+        public static ..ValueDelegateOr<TActual> Create(. assertionBuilder) { }
+    }
+    public class ValueOr<TActual> : ..ISource, ..IValueSource<TActual>
+    {
+        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 class AndAssertionBuilder : ., . { }
+    public abstract class AssertionBuilder : ..ISource
+    {
+        protected .AssertionData? AwaitedAssertionData;
+        protected .? OtherTypeAssertionBuilder;
+        protected readonly .<.> Results;
+        public AssertionBuilder(..ISource source) { }
+        public AssertionBuilder(.LazyAssertionData lazyAssertionData, string? actualExpression) { }
+        public AssertionBuilder(.LazyAssertionData lazyAssertionData, 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) { }
+        [.DebuggerHidden]
+        [("This is a base `object` method that should not be called.", true)]
+        public void ReferenceEquals(object a, object b) { }
+    }
+    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 ConvertedDelegateAssertionBuilder(..IDelegateSource source) { }
+    }
+    public class ConvertedValueAssertionBuilder<TFromType, TToType> : .<TToType>
+    {
+        public ConvertedValueAssertionBuilder(..IValueSource<TFromType> source, .<TFromType, TToType> convertToAssertCondition) { }
+    }
+    public class DelegateAssertionBuilder : ., ..IDelegateSource, ..ISource { }
+    public interface IAndAssertionBuilder { }
+    public interface IInvokableAssertionBuilder : ..ISource
+    {
+        . GetAwaiter();
+        string? GetExpression();
+    }
+    public interface IOrAssertionBuilder { }
+    public class InvokableAssertionBuilder<TActual> : ., ..ISource, .
+    {
+        protected readonly ..ISource Source;
+        protected .<.> Assertions { get; }
+        public .<.<.>> GetAssertionResults() { }
+        public . GetAwaiter() { }
+    }
+    public class InvokableDelegateAssertionBuilder : .<object?>, ..IDelegateSource, ..ISource
+    {
+        public ..DelegateAnd<object?> And { get; }
+        public . AssertionBuilder { get; }
+        public ..DelegateOr<object?> Or { get; }
+    }
+    public class InvokableValueAssertionBuilder<TActual> : .<TActual>, ..ISource, ..IValueSource<TActual>
+    {
+        public InvokableValueAssertionBuilder(..ISource source) { }
+        public ..ValueAnd<TActual> And { get; }
+        public ..ValueOr<TActual> Or { get; }
+        public .<TActual> Because(string reason) { }
+        public new .<TActual?> GetAwaiter() { }
+    }
+    public class InvokableValueDelegateAssertionBuilder<TActual> : .<TActual>
+    {
+        public ..ValueDelegateAnd<TActual> And { get; }
+        public . AssertionBuilder { get; }
+        public ..ValueDelegateOr<TActual> Or { get; }
+    }
+    public class MappableResultAssertionBuilder<TActual, TExpected> : .<TActual>
+    {
+        public MappableResultAssertionBuilder(.<TActual> assertionBuilder, <TActual?, TExpected?> mapper) { }
+        public new .<TExpected?> GetAwaiter() { }
+    }
+    public class MappableResultAssertionBuilder<TActual, TAssertCondition, TExpected> : .<TActual>
+        where TAssertCondition : .<TActual>
+    {
+        public MappableResultAssertionBuilder(.<TActual> assertionBuilder, TAssertCondition assertCondition, <TActual?, TAssertCondition, TExpected?> mapper) { }
+        public new .<TExpected?> GetAwaiter() { }
+    }
+    public class OrAssertionBuilder : ., . { }
+    public class ValueAssertionBuilder<TActual> : ., ..ISource, ..IValueSource<TActual>
+    {
+        public ValueAssertionBuilder(..ISource source) { }
+    }
+    public class ValueDelegateAssertionBuilder<TActual> : ., ..IDelegateSource, ..ISource, ..IValueDelegateSource<TActual>, ..IValueSource<TActual> { }
+}
+namespace .
+{
+    public class AndAssertionGroupInvoker<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public AndAssertionGroupInvoker(..AssertionGroup<TActual, TAssertionBuilder> group1, ..AssertionGroup<TActual, TAssertionBuilder> group2) { }
+        public ..AndAssertionGroupInvoker<TActual, TAssertionBuilder> And(..AssertionGroup<TActual, TAssertionBuilder> group) { }
+        public .<TActual?> GetAwaiter() { }
+    }
+    public class AndAssertionGroup<TActual, TAssertionBuilder> : ..AssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public ..AndAssertionGroup<TActual, TAssertionBuilder> And(<TAssertionBuilder, .<TActual>> assert) { }
+        public override .<TActual?> GetAwaiter() { }
+    }
+    [.("Usage", "TUnitAssertions0002:Assert statements must be awaited", Justification="This is a factory class for creating assertion groups. The factory methods return" +
+        " builders that create awaitable assertion groups; the factory methods themselves" +
+        " are not awaitable.")]
+    [.("Usage", "TUnitAssertions0008:ValueTasks should be awaited when used within (..." +
+        ")", Justification="The () calls within this factory class return assertion builders that " +
+        "will be composed into groups and awaited by the consumer. The factory methods th" +
+        "emselves do not need to await these builders.")]
+    public static class AssertionGroup
+    {
+        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 class AssertionGroupBuilder<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public ..UnknownAssertionGroup<TActual, TAssertionBuilder> WithAssertion(<TAssertionBuilder, .<TActual>> assert) { }
+    }
+    public abstract class AssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public abstract .<TActual?> GetAwaiter();
+    }
+    public class OrAssertionException : 
+    {
+        public OrAssertionException(.<> exceptions) { }
+        public override string Message { get; }
+    }
+    public class OrAssertionGroupInvoker<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public OrAssertionGroupInvoker(..AssertionGroup<TActual, TAssertionBuilder> group1, ..AssertionGroup<TActual, TAssertionBuilder> group2) { }
+        public .<TActual?> GetAwaiter() { }
+        public ..OrAssertionGroupInvoker<TActual, TAssertionBuilder> Or(..AssertionGroup<TActual, TAssertionBuilder> group) { }
+    }
+    public class OrAssertionGroup<TActual, TAssertionBuilder> : ..AssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public override .<TActual?> GetAwaiter() { }
+        public ..OrAssertionGroup<TActual, TAssertionBuilder> Or(<TAssertionBuilder, .<TActual>> assert) { }
+    }
+    public class UnknownAssertionGroupInvoker<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        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 class UnknownAssertionGroup<TActual, TAssertionBuilder>
+        where TAssertionBuilder : .
+    {
+        public ..AndAssertionGroup<TActual, TAssertionBuilder> And(<TAssertionBuilder, .<TActual>> assert) { }
+        public ..OrAssertionGroup<TActual, TAssertionBuilder> Or(<TAssertionBuilder, .<TActual>> assert) { }
+    }
+}
+namespace .
+{
+    public class BetweenAssertionBuilderWrapper<TActual> : .<TActual>
+        where TActual : <TActual>
+    {
+        public ..BetweenAssertionBuilderWrapper<TActual> WithExclusiveBounds() { }
+        public ..BetweenAssertionBuilderWrapper<TActual> WithInclusiveBounds() { }
+    }
+    public class DateOnlyEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..DateOnlyEqualToAssertionBuilderWrapper WithinDays(int days, [.("days")] string doNotPopulateThis = "") { }
+    }
+    public class DateTimeEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..DateTimeEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
+    }
+    public class DateTimeOffsetEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..DateTimeOffsetEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
+    }
+    public class EquivalentToAssertionBuilderWrapper<TActual, TExpected> : .<TActual>
+    {
+        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 NotNullAssertionBuilderWrapper<TActual> : .<TActual>
+        where TActual :  class
+    {
+        public new .<TActual> GetAwaiter() { }
+    }
+    public class NotNullStructAssertionBuilderWrapper<TActual> : .<TActual>
+        where TActual :  struct
+    {
+        public new .<TActual> GetAwaiter() { }
+    }
+    public class ParseAssertionBuilderWrapper<[.(..None | ..PublicMethods | ..Interfaces)]  TTarget> : .<string?>
+    {
+        public .<string?> WithFormatProvider(? formatProvider) { }
+    }
+    public class SingleItemAssertionBuilderWrapper<TActual, TInner> : .<TActual>
+        where TActual : .<TInner>
+    {
+        public new .<TInner> GetAwaiter() { }
+    }
+    public class StringContainsAssertionBuilderWrapper : .<string>
+    {
+        public ..StringContainsAssertionBuilderWrapper IgnoringWhitespace() { }
+        public ..StringContainsAssertionBuilderWrapper WithTrimming() { }
+    }
+    public class StringEqualToAssertionBuilderWrapper : .<string>
+    {
+        public ..StringEqualToAssertionBuilderWrapper IgnoringWhitespace() { }
+        public ..StringEqualToAssertionBuilderWrapper WithNullAndEmptyEquality() { }
+        public ..StringEqualToAssertionBuilderWrapper WithTrimming() { }
+    }
+    public class TimeOnlyEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..TimeOnlyEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
+    }
+    public class TimeSpanEqualToAssertionBuilderWrapper : .<>
+    {
+        public ..TimeSpanEqualToAssertionBuilderWrapper Within( tolerance, [.("tolerance")] string doNotPopulateThis = "") { }
+    }
+}
+namespace .
+{
+    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
+    {
+        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 ..Conditions
+{
+    public class EnumDoesNotHaveFlagAssertCondition<TEnum> : .<TEnum>
+        where TEnum : 
+    {
+        public EnumDoesNotHaveFlagAssertCondition(TEnum expected) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(TEnum? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class EnumDoesNotHaveSameNameAsCondition<TEnum, TExpected> : .<TEnum>
+        where TEnum : 
+        where TExpected : 
+    {
+        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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  TActual, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  TActual, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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<[.(..None | ..PublicMethods | ..Interfaces)]  TTarget> : .<string?, TTarget>
+    {
+        public ParseConversionAssertCondition(? formatProvider = null) { }
+        [.("AOT", "IL3050:Calling members annotated with \'RequiresDynamicCodeAttribute\' may break fu" +
+            "nctionality when AOT compiling.", Justification="The generic type is preserved through the DynamicallyAccessedMembers attribute")]
+        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<[.(..None | ..PublicMethods | ..Interfaces)]  TTarget> : .<string?, ?>
+    {
+        public StringIsNotParsableCondition(? formatProvider = null) { }
+        protected override string GetExpectation() { }
+        [.("AOT", "IL3050:Calling members annotated with \'RequiresDynamicCodeAttribute\' may break fu" +
+            "nctionality when AOT compiling.", Justification="The generic type is preserved through the DynamicallyAccessedMembers attribute")]
+        protected override .<.> GetResult(string? actualValue, ? formatProvider) { }
+    }
+    public class StringIsParsableCondition<[.(..None | ..PublicMethods | ..Interfaces)]  TTarget> : .<string?, ?>
+    {
+        public StringIsParsableCondition(? formatProvider = null) { }
+        protected override string GetExpectation() { }
+        [.("AOT", "IL3050:Calling members annotated with \'RequiresDynamicCodeAttribute\' may break fu" +
+            "nctionality when AOT compiling.", Justification="The generic type is preserved through the DynamicallyAccessedMembers attribute")]
+        protected override .<.> GetResult(string? actualValue, ? formatProvider) { }
+    }
+}
+namespace .
+{
+    public static class StringParsingExtensions
+    {
+        public static ..ParseAssertionBuilderWrapper<TTarget> IsNotParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  TTarget>(this ..IValueSource<string> valueSource, [.("valueSource")] string? doNotPopulateThisValue = null) { }
+        public static ..ParseAssertionBuilderWrapper<TTarget> IsParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  TTarget>(this ..IValueSource<string> valueSource, [.("valueSource")] string? doNotPopulateThisValue = null) { }
+        public static .<TTarget> WhenParsedInto<[.(..None | ..PublicMethods | ..Interfaces)]  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; }
+    }
+    [(.Class, AllowMultiple=true)]
+    public class CreateAssertionAttribute<TTarget> : 
+    {
+        public CreateAssertionAttribute(string methodName) { }
+        public CreateAssertionAttribute( 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; }
+    }
+}
+namespace .Enums
+{
+    public enum CollectionOrdering
+    {
+        Matching = 0,
+        Any = 1,
+    }
+    public enum EquivalencyKind
+    {
+        Full = 0,
+        Partial = 1,
+    }
+    public enum Order
+    {
+        Ascending = 0,
+        Descending = 1,
+    }
+}
+namespace .Equality
+{
+    public class CollectionEquivalentToEqualityComparer<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  T> : .<T>
+    {
+        public CollectionEquivalentToEqualityComparer() { }
+        public CollectionEquivalentToEqualityComparer(.CompareOptions compareOptions) { }
+        public override int? EnumerableIndex { get; protected set; }
+        public override bool Equals(T? x, T? y) { }
+    }
+    public class EquivalentToEqualityComparer<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  T> : .<T>
+    {
+        public EquivalentToEqualityComparer() { }
+        public EquivalentToEqualityComparer(.CompareOptions compareOptions) { }
+        public .ComparisonFailure[]? ComparisonFailures { get; }
+        public virtual int? EnumerableIndex { get; protected set; }
+        public virtual bool Equals(T? x, T? y) { }
+        public string GetFailureMessages() { }
+        public int GetHashCode([.] T obj) { }
+    }
+}
+namespace .Exceptions
+{
+    public class AssertionException : .
+    {
+        public AssertionException(string? message) { }
+        public AssertionException(string? message,  innerException) { }
+    }
+    public class BaseAssertionException : 
+    {
+        public BaseAssertionException() { }
+        public BaseAssertionException(string? message) { }
+        public BaseAssertionException(string? message, ? innerException) { }
+    }
+    public class MaybeCaughtException : 
+    {
+        public MaybeCaughtException( exception) { }
+    }
+    public class MixedAndOrAssertionsException : .
+    {
+        public MixedAndOrAssertionsException() { }
+    }
+}
+namespace .Extensions
+{
+    public class AggregateExceptionExceptionAssertionExtensionsHasMultipleInnerExceptionsWithAggregateExceptionAssertCondition : .<>
+    {
+        public AggregateExceptionExceptionAssertionExtensionsHasMultipleInnerExceptionsWithAggregateExceptionAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class AssemblyAssemblyAssertionExtensionsIsDebugBuildWithAssemblyAssertCondition : .<.Assembly>
+    {
+        public AssemblyAssemblyAssertionExtensionsIsDebugBuildWithAssemblyAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class AssemblyAssemblyAssertionExtensionsIsSignedWithAssemblyAssertCondition : .<.Assembly>
+    {
+        public AssemblyAssemblyAssertionExtensionsIsSignedWithAssemblyAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    [.<.Assembly>("IsCollectible")]
+    [.<.Assembly>("IsCollectible", CustomName="IsNotCollectible", 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> IsCollectible(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> IsNotCollectible(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsNotDynamic(this ..IValueSource<.Assembly> valueSource) { }
+        public static .<.Assembly> IsNotFullyTrusted(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 AssemblyIsCollectibleAssertCondition : .<.Assembly>
+    {
+        public AssemblyIsCollectibleAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.Assembly? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class AssemblyIsDynamicAssertCondition : .<.Assembly>
+    {
+        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 class CancellationTokenCancellationTokenAssertionExtensionsIsNoneWithCancellationTokenAssertCondition : .<.CancellationToken>
+    {
+        public CancellationTokenCancellationTokenAssertionExtensionsIsNoneWithCancellationTokenAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(.CancellationToken actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class CancellationTokenIsCancellationRequestedAssertCondition : .<.CancellationToken>
+    {
+        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 class CharIsDigitWithCharAssertCondition : .<char>
+    {
+        public CharIsDigitWithCharAssertCondition(bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(char actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public static class CharIsExtensions
+    {
+        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 class CharIsHighSurrogateWithCharAssertCondition : .<char>
+    {
+        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) { }
+    }
+    [.("Usage", "TUnitAssertions0003:Compiler argument populated")]
+    public static class CollectionsIsExtensions
+    {
+        public static .<.<TInner>> IsEmpty<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<TActual> IsEquivalentTo<TActual, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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) { }
+    }
+    public static class DateOnlyIsExtensions
+    {
+        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 ..DateOnlyEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+    }
+    [.<>(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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  TActual, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  TActual, [.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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) { }
+        [.("Expression compilation requires dynamic code generation")]
+        [.("Expression compilation requires unreferenced code")]
+        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) { }
+    }
+    [.("Usage", "TUnitAssertions0003:Compiler argument populated")]
+    public static class ImmutableArrayIsExtensions
+    {
+        public static .<.<TInner>> IsEmpty<TInner>(this ..IValueSource<.<TInner>> valueSource) { }
+        public static .<.<TInner>> IsEquivalentTo<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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<[.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties | ..NonPublicProperties)]  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) { }
+    }
+    public static class NumberIsExtensions
+    {
+        public static .<TActual> IsDivisibleBy<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .INumber<TActual>, .IModulusOperators<TActual, TActual, TActual> { }
+        public static .<TActual> IsEven<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual>, .IModulusOperators<TActual, TActual, TActual> { }
+        public static .<TActual> IsNegative<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsOdd<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual>, .IModulusOperators<TActual, TActual, TActual> { }
+        public static .<TActual> IsPositive<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsZero<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual> { }
+        public static ..GenericEqualToAssertionBuilderWrapper<TActual> Within<TActual>(this ..GenericEqualToAssertionBuilderWrapper<TActual> assertionBuilder, TActual tolerance, [.("tolerance")] string doNotPopulateThis = "")
+            where TActual : .INumber<TActual> { }
+    }
+    public static class NumberIsNotExtensions
+    {
+        public static .<TActual> IsNotDivisibleBy<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .INumber<TActual>, .IModulusOperators<TActual, TActual, TActual> { }
+        public static .<TActual> IsNotEven<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual>, .IModulusOperators<TActual, int, int> { }
+        public static .<TActual> IsNotGreaterThan<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsNotGreaterThanOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsNotLessThan<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsNotLessThanOrEqualTo<TActual>(this ..IValueSource<TActual> valueSource, TActual expected, [.("expected")] string doNotPopulateThisValue = null)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsNotNegative<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsNotOdd<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual>, .IModulusOperators<TActual, int, int> { }
+        public static .<TActual> IsNotPositive<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual> { }
+        public static .<TActual> IsNotZero<TActual>(this ..IValueSource<TActual> valueSource)
+            where TActual : .INumber<TActual> { }
+        public static ..GenericNotEqualToAssertionBuilderWrapper<TActual> Within<TActual>(this ..GenericNotEqualToAssertionBuilderWrapper<TActual> assertionBuilder, TActual tolerance, [.("tolerance")] string doNotPopulateThis = "")
+            where TActual : .INumber<TActual> { }
+    }
+    [.<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>("CanTimeout")]
+    [.<.Stream>("CanTimeout", CustomName="CannotTimeout", 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> CanTimeout(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> CannotTimeout(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 StreamCanTimeoutAssertCondition : .<.Stream>
+    {
+        public StreamCanTimeoutAssertCondition(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, char value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> DoesNotContain(this ..IValueSource<string> valueSource, string value, [.("value")] string? doNotPopulateThisValue1 = null) { }
+        public static .<string> DoesNotContain(this ..IValueSource<string> valueSource, char value,  comparisonType, [.("value")] string? doNotPopulateThisValue1 = null, [.("comparisonType")] string? doNotPopulateThisValue2 = null) { }
+        public static .<string> DoesNotContain(this ..IValueSource<string> valueSource, string value,  comparisonType, [.("value")] string? doNotPopulateThisValue1 = null, [.("comparisonType")] string? doNotPopulateThisValue2 = null) { }
+        public static .<string> DoesNotEndWith(this ..IValueSource<string> valueSource, char 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, char value, [.("value")] string? doNotPopulateThisValue1 = 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, char value, [.("value")] string? doNotPopulateThisValue1 = 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, char value, [.("value")] string? doNotPopulateThisValue1 = 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 StringContainsWithCharAnd1MoreAssertCondition : .<string>
+    {
+        public StringContainsWithCharAnd1MoreAssertCondition(char value,  comparisonType, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringContainsWithCharAssertCondition : .<string>
+    {
+        public StringContainsWithCharAssertCondition(char value, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? actualValue, ? exception, .AssertionMetadata assertionMetadata) { }
+    }
+    public class StringContainsWithStringAnd1MoreAssertCondition : .<string>
+    {
+        public StringContainsWithStringAnd1MoreAssertCondition(string value,  comparisonType, bool negated = false) { }
+        protected override string GetExpectation() { }
+        protected override .<.> GetResult(string? 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 StringEndsWithWithCharAssertCondition : .<string>
+    {
+        public StringEndsWithWithCharAssertCondition(char 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 StringStartsWithWithCharAssertCondition : .<string>
+    {
+        public StringStartsWithWithCharAssertCondition(char value, 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)]
+    [.<.>("IsCompletedSuccessfully")]
+    [.<.>("IsCompletedSuccessfully", CustomName="IsNotCompletedSuccessfully", 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 .<.> IsCompletedSuccessfully(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsFaulted(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotCanceled(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotCompleted(this ..IValueSource<.> valueSource) { }
+        public static .<.> IsNotCompletedSuccessfully(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 TaskIsCompletedSuccessfullyAssertCondition : .<.>
+    {
+        public TaskIsCompletedSuccessfullyAssertCondition(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 :  { }
+    }
+    public static class TimeOnlyIsExtensions
+    {
+        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 ..TimeOnlyEqualToAssertionBuilderWrapper IsEqualTo(this ..IValueSource<> valueSource,  expected, [.("expected")] string doNotPopulateThisValue1 = null) { }
+    }
+    [.<>(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)]
+    [.<>("IsAssignableTo")]
+    [.<>("IsAssignableTo", CustomName="IsNotAssignableTo", 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)]
+    [.<>("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 .<> IsAssignableTo(this ..IValueSource<> valueSource, ? targetType, [.("targetType")] 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 .<> IsNotAssignableTo(this ..IValueSource<> valueSource, ? targetType, [.("targetType")] 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 .<> IsPrimitive(this ..IValueSource<> valueSource) { }
+        public static .<> IsPublic(this ..IValueSource<> valueSource) { }
+        public static .<> IsReferenceType(this ..IValueSource<> valueSource) { }
+        public static .<> IsSealed(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 TypeIsAssignableToWithTypeAssertCondition : .<>
+    {
+        public TypeIsAssignableToWithTypeAssertCondition(? targetType, 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 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
+{
+    public static class ExpressionHelpers
+    {
+        public static string GetName<T1, T2>(.<<T1, T2>> exp) { }
+    }
+    public abstract class Formatter
+    {
+        protected Formatter() { }
+        public abstract bool CanHandle(object? value);
+        public abstract string FormatValue(object? value);
+        public static string Format(object? value) { }
+    }
+    public class StringDifference
+    {
+        public StringDifference(string? actualValue, string? expectedValue, .<string>? comparer = null) { }
+        public int IgnoreWhiteSpace { get; set; }
+        public int? OverriddenIndex { get; set; }
+        public int IndexOfFirstMismatch() { }
+        public override string ToString() { }
+        public string ToString(string prefix) { }
+    }
+    public static class TimeSpanFormatter
+    {
+        public static string PrettyPrint(this  timeSpan) { }
+    }
+}
\ No newline at end of file
diff --git a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..0796ca3247
--- /dev/null
+++ b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -0,0 +1,2602 @@
+[assembly: .(@", PublicKey=0024000004800000940000000602000000240000525341310004000001000100698a70398fa0b2230c5a72e3bd9d56b48f809f6173e49a19fbb942d621be93ad48c5566b47b28faabc359b9ad3ff4e00bbdea88f5bdfa250f391fedd28182b2e37b55d429c0151a42a98ea7a5821818cd15a79fef9903e8607a88304cf3e0317bf86ec96e32e1381535a6582251e5a6eed40b5a3ed82bc444598b1269cce57a7")]
+[assembly: .(@", PublicKey=0024000004800000940000000602000000240000525341310004000001000100698a70398fa0b2230c5a72e3bd9d56b48f809f6173e49a19fbb942d621be93ad48c5566b47b28faabc359b9ad3ff4e00bbdea88f5bdfa250f391fedd28182b2e37b55d429c0151a42a98ea7a5821818cd15a79fef9903e8607a88304cf3e0317bf86ec96e32e1381535a6582251e5a6eed40b5a3ed82bc444598b1269cce57a7")]
+[assembly: .(".NETCoreApp,Version=v10.0", FrameworkDisplayName=".NET 10.0")]
+namespace 
+{
+    public abstract class AbstractDynamicTest
+    {
+        protected AbstractDynamicTest() { }
+        public abstract .<.DiscoveryResult> GetTests();
+    }
+    public abstract class AbstractDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T> : .AbstractDynamicTest
+        where T :  class
+    {
+        protected AbstractDynamicTest() { }
+    }
+    [.DebuggerDisplay("{.Name}.{}")]
+    public abstract class AbstractExecutableTest
+    {
+        protected AbstractExecutableTest() { }
+        public required object?[] Arguments { get; init; }
+        public object?[] ClassArguments { get; init; }
+        public . CompletionTask { get; }
+        public required .TestContext Context { get; init; }
+        public .ResolvedDependency[] Dependencies { get; set; }
+        public ? Duration { get; }
+        public ? EndTime { get; set; }
+        public .? ExecutionContext { get; set; }
+        public .? ExecutionTask { get; }
+        public virtual .TestMetadata Metadata { get; init; }
+        public .TestResult? Result { get; set; }
+        public ? StartTime { get; set; }
+        public .TestState State { get; set; }
+        public required string TestId { get; init; }
+        public abstract .<object> CreateInstanceAsync();
+        public abstract . InvokeTestAsync(object instance, .CancellationToken cancellationToken);
+        public void SetResult(.TestState state, ? exception = null) { }
+    }
+    [(.Method)]
+    public sealed class AfterAttribute : .HookAttribute
+    {
+        public AfterAttribute(.HookType hookType, [.] string file = "", [.] int line = 0) { }
+    }
+    [(.Method)]
+    public sealed class AfterEveryAttribute : .HookAttribute
+    {
+        public AfterEveryAttribute(.HookType hookType, [.] string file = "", [.] int line = 0) { }
+    }
+    public abstract class ArgumentDisplayFormatter
+    {
+        protected ArgumentDisplayFormatter() { }
+        public abstract bool CanHandle(object? value);
+        public abstract string FormatValue(object? value);
+    }
+    public abstract class ArgumentDisplayFormatterAttribute : .TUnitAttribute, ., .
+    {
+        protected ArgumentDisplayFormatterAttribute() { }
+        public abstract .ArgumentDisplayFormatter Formatter { get; }
+        public virtual int Order { get; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    [(.Assembly | .Class | .Method, AllowMultiple=true)]
+    public class ArgumentDisplayFormatterAttribute<T> : .ArgumentDisplayFormatterAttribute
+        where T : .ArgumentDisplayFormatter, new ()
+    {
+        public ArgumentDisplayFormatterAttribute() { }
+        public override .ArgumentDisplayFormatter Formatter { get; }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public sealed class ArgumentsAttribute : , .IDataSourceAttribute, ., .
+    {
+        public ArgumentsAttribute(params object?[]? values) { }
+        public int Order { get; }
+        public string? Skip { get; set; }
+        public object?[] Values { get; }
+        [.(typeof(.ArgumentsAttribute.<GetDataRowsAsync>d__8))]
+        public .<<.<object?[]?>>> GetDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public sealed class ArgumentsAttribute<T> : .TypedDataSourceAttribute<T>, ., .
+    {
+        public ArgumentsAttribute(T value) { }
+        public int Order { get; }
+        public string? Skip { get; set; }
+        [.(typeof(.ArgumentsAttribute<T>.<GetTypedDataRowsAsync>d__6))]
+        public override .<<.<T>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    public class Artifact
+    {
+        public Artifact() { }
+        public string? Description { get; init; }
+        public required string DisplayName { get; init; }
+        public required .FileInfo File { get; init; }
+    }
+    [.DebuggerDisplay("{().Name}")]
+    public class AssemblyHookContext : .Context
+    {
+        public .<.TestContext> AllTests { get; }
+        public required .Assembly Assembly { get; init; }
+        public .<.ClassHookContext> TestClasses { get; }
+        public int TestCount { get; }
+        public .TestSessionContext TestSessionContext { get; }
+        public new static .AssemblyHookContext? Current { get; }
+        public void AddClass(.ClassHookContext classHookContext) { }
+    }
+    [.DebuggerDisplay("{Name})")]
+    public class AssemblyMetadata : <.AssemblyMetadata>
+    {
+        public AssemblyMetadata() { }
+        public required string Name { get; init; }
+        public virtual bool Equals(.AssemblyMetadata? other) { }
+        public override int GetHashCode() { }
+        public static .AssemblyMetadata GetOrAdd(string name, <.AssemblyMetadata> factory) { }
+    }
+    public static class AsyncConvert
+    {
+        public static . Convert( action) { }
+        public static . Convert(<.> action) { }
+        public static . Convert(<.> action) { }
+        [.("ConvertObject may require dynamic invocation for custom awaitable types. For AOT " +
+            "compatibility, use Task or ValueTask directly.")]
+        [.("ConvertObject uses reflection to handle custom awaitable types and F# async. For " +
+            "AOT compatibility, use Task or ValueTask directly.")]
+        public static . ConvertObject(object? invoke) { }
+        [.("Custom awaitable handling may require dynamic invocation. For AOT, use Task/Value" +
+            "Task.")]
+        [.("GetAwaiter pattern detection requires reflection for custom awaitable types. For " +
+            "AOT, use Task/ValueTask.")]
+        public static bool TryGetAwaitableTask(object awaitable, [.(true)] out .? task) { }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public abstract class AsyncDataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T> : .TypedDataSourceAttribute<T>
+    {
+        protected AsyncDataSourceGeneratorAttribute() { }
+        protected abstract .<<.<T>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.AsyncDataSourceGeneratorAttribute<T>.<GetTypedDataRowsAsync>d__1))]
+        public override sealed .<<.<T>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class AsyncDataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2> : .TypedDataSourceAttribute<<T1, T2>>
+    {
+        protected AsyncDataSourceGeneratorAttribute() { }
+        protected abstract .<<.<<T1, T2>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.AsyncDataSourceGeneratorAttribute<T1, T2>.<GetTypedDataRowsAsync>d__1))]
+        public override sealed .<<.<<T1, T2>>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class AsyncDataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T3> : .TypedDataSourceAttribute<<T1, T2, T3>>
+    {
+        protected AsyncDataSourceGeneratorAttribute() { }
+        protected abstract .<<.<<T1, T2, T3>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.AsyncDataSourceGeneratorAttribute<T1, T2, T3>.<GetTypedDataRowsAsync>d__1))]
+        public override sealed .<<.<<T1, T2, T3>>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class AsyncDataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T4> : .TypedDataSourceAttribute<<T1, T2, T3, T4>>
+    {
+        protected AsyncDataSourceGeneratorAttribute() { }
+        protected abstract .<<.<<T1, T2, T3, T4>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.AsyncDataSourceGeneratorAttribute<T1, T2, T3, T4>.<GetTypedDataRowsAsync>d__1))]
+        public override .<<.<<T1, T2, T3, T4>>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class AsyncDataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T4, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T5> : .TypedDataSourceAttribute<<T1, T2, T3, T4, T5>>
+    {
+        protected AsyncDataSourceGeneratorAttribute() { }
+        protected abstract .<<.<<T1, T2, T3, T4, T5>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.AsyncDataSourceGeneratorAttribute<T1, T2, T3, T4, T5>.<GetTypedDataRowsAsync>d__1))]
+        public override .<<.<<T1, T2, T3, T4, T5>>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    public class AsyncEvent<TEventArgs>
+    {
+        public AsyncEvent() { }
+        public int Order { get; set; }
+        public .AsyncEvent<TEventArgs> InsertAtFront(<object, TEventArgs, .> callback) { }
+        public static .AsyncEvent<TEventArgs> operator +(.AsyncEvent<TEventArgs>? e, <object, TEventArgs, .> callback) { }
+        public class Invocation : .
+        {
+            public Invocation(<object, TEventArgs, .> factory, int order) { }
+            public int Order { get; }
+            public . InvokeAsync(object sender, TEventArgs eventArgs) { }
+        }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    [.("AsyncUntypedDataSourceGeneratorAttribute requires dynamic code generation for run" +
+        "time data source creation. Consider using strongly-typed AsyncDataSourceGenerato" +
+        "rAttribute<T> overloads for AOT compatibility.")]
+    [.("AsyncUntypedDataSourceGeneratorAttribute may require unreferenced code for runtim" +
+        "e data source creation. Consider using strongly-typed AsyncDataSourceGeneratorAt" +
+        "tribute<T> overloads for AOT compatibility.")]
+    public abstract class AsyncUntypedDataSourceGeneratorAttribute : , .IDataSourceAttribute
+    {
+        protected AsyncUntypedDataSourceGeneratorAttribute() { }
+        [.(typeof(.AsyncUntypedDataSourceGeneratorAttribute.<GenerateAsync>d__1))]
+        public .<<.<object?[]?>>> GenerateAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        protected abstract .<<.<object?[]?>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+        public .<<.<object?[]?>>> GetDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Method)]
+    public abstract class BaseTestAttribute : .TUnitAttribute
+    {
+        public readonly string File;
+        public readonly int Line;
+    }
+    [(.Method)]
+    public sealed class BeforeAttribute : .HookAttribute
+    {
+        public BeforeAttribute(.HookType hookType, [.] string file = "", [.] int line = 0) { }
+    }
+    [(.Method)]
+    public sealed class BeforeEveryAttribute : .HookAttribute
+    {
+        public BeforeEveryAttribute(.HookType hookType, [.] string file = "", [.] int line = 0) { }
+    }
+    public class BeforeTestDiscoveryContext : .Context
+    {
+        public .GlobalContext GlobalContext { get; }
+        public required string? TestFilter { get; init; }
+        public new static .BeforeTestDiscoveryContext? Current { get; }
+    }
+    [(.Assembly | .Class | .Method, AllowMultiple=true)]
+    public class CategoryAttribute : .TUnitAttribute, ., .
+    {
+        public CategoryAttribute(string category) { }
+        public string Category { get; }
+        public int Order { get; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    [(.Assembly | .Class)]
+    public class ClassConstructorAttribute : .TUnitAttribute
+    {
+        public ClassConstructorAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  classConstructorType) { }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]
+        public  ClassConstructorType { get; init; }
+    }
+    [(.Assembly | .Class)]
+    public sealed class ClassConstructorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T> : .ClassConstructorAttribute
+        where T : ., new ()
+    {
+        public ClassConstructorAttribute() { }
+    }
+    public class ClassConstructorMetadata : <.ClassConstructorMetadata>
+    {
+        public ClassConstructorMetadata() { }
+        public required .TestBuilderContext TestBuilderContext { get; init; }
+        public required string TestSessionId { get; init; }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    [.("ClassDataSourceAttribute may require runtime type generation. For AOT compatibili" +
+        "ty, use strongly-typed ClassDataSourceAttribute<T> instead.")]
+    [.("ClassDataSourceAttribute uses reflection to instantiate and access test data clas" +
+        "ses. For AOT compatibility, use strongly-typed ClassDataSourceAttribute<T> inste" +
+        "ad.")]
+    public sealed class ClassDataSourceAttribute : .UntypedDataSourceGeneratorAttribute
+    {
+        [.("ClassDataSourceAttribute may require runtime type generation. For AOT compatibili" +
+            "ty, use strongly-typed ClassDataSourceAttribute<T> instead.")]
+        [.("ClassDataSourceAttribute uses reflection to instantiate and access test data clas" +
+            "ses. For AOT compatibility, use strongly-typed ClassDataSourceAttribute<T> inste" +
+            "ad.")]
+        public ClassDataSourceAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type) { }
+        [.("Reflection")]
+        [.("Reflection")]
+        public ClassDataSourceAttribute(params [] types) { }
+        [.("ClassDataSourceAttribute may require runtime type generation. For AOT compatibili" +
+            "ty, use strongly-typed ClassDataSourceAttribute<T> instead.")]
+        [.("ClassDataSourceAttribute uses reflection to instantiate and access test data clas" +
+            "ses. For AOT compatibility, use strongly-typed ClassDataSourceAttribute<T> inste" +
+            "ad.")]
+        public ClassDataSourceAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type2) { }
+        [.("ClassDataSourceAttribute may require runtime type generation. For AOT compatibili" +
+            "ty, use strongly-typed ClassDataSourceAttribute<T> instead.")]
+        [.("ClassDataSourceAttribute uses reflection to instantiate and access test data clas" +
+            "ses. For AOT compatibility, use strongly-typed ClassDataSourceAttribute<T> inste" +
+            "ad.")]
+        public ClassDataSourceAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type3) { }
+        [.("ClassDataSourceAttribute may require runtime type generation. For AOT compatibili" +
+            "ty, use strongly-typed ClassDataSourceAttribute<T> instead.")]
+        [.("ClassDataSourceAttribute uses reflection to instantiate and access test data clas" +
+            "ses. For AOT compatibility, use strongly-typed ClassDataSourceAttribute<T> inste" +
+            "ad.")]
+        public ClassDataSourceAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type4) { }
+        [.("ClassDataSourceAttribute may require runtime type generation. For AOT compatibili" +
+            "ty, use strongly-typed ClassDataSourceAttribute<T> instead.")]
+        [.("ClassDataSourceAttribute uses reflection to instantiate and access test data clas" +
+            "ses. For AOT compatibility, use strongly-typed ClassDataSourceAttribute<T> inste" +
+            "ad.")]
+        public ClassDataSourceAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type4, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  type5) { }
+        public string[] Keys { get; set; }
+        public .SharedType[] Shared { get; set; }
+        [.("Reflection")]
+        [.("Reflection")]
+        protected override .<<object?[]?>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public .<string> GetKeys() { }
+        public .<.SharedType> GetSharedTypes() { }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public sealed class ClassDataSourceAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T> : .DataSourceGeneratorAttribute<T>
+    {
+        public ClassDataSourceAttribute() { }
+        public  ClassType { get; }
+        public string Key { get; set; }
+        public .SharedType Shared { get; set; }
+        protected override .<<T>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public .<string> GetKeys() { }
+        public .<.SharedType> GetSharedTypes() { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public sealed class ClassDataSourceAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T2> : .DataSourceGeneratorAttribute<T1, T2>
+        where T1 : new()
+        where T2 : new()
+    {
+        public ClassDataSourceAttribute() { }
+        public string[] Keys { get; set; }
+        public .SharedType[] Shared { get; set; }
+        protected override .<<<T1, T2>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public .<string> GetKeys() { }
+        public .<.SharedType> GetSharedTypes() { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public sealed class ClassDataSourceAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T3> : .DataSourceGeneratorAttribute<T1, T2, T3>
+        where T1 : new()
+        where T2 : new()
+        where T3 : new()
+    {
+        public ClassDataSourceAttribute() { }
+        public string[] Keys { get; set; }
+        public .SharedType[] Shared { get; set; }
+        protected override .<<<T1, T2, T3>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public .<string> GetKeys() { }
+        public .<.SharedType> GetSharedTypes() { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public sealed class ClassDataSourceAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T4> : .DataSourceGeneratorAttribute<T1, T2, T3, T4>
+        where T1 : new()
+        where T2 : new()
+        where T3 : new()
+        where T4 : new()
+    {
+        public ClassDataSourceAttribute() { }
+        public string[] Keys { get; set; }
+        public .SharedType[] Shared { get; set; }
+        protected override .<<<T1, T2, T3, T4>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public .<string> GetKeys() { }
+        public .<.SharedType> GetSharedTypes() { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public sealed class ClassDataSourceAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T4, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T5> : .DataSourceGeneratorAttribute<T1, T2, T3, T4, T5>
+        where T1 : new()
+        where T2 : new()
+        where T3 : new()
+        where T4 : new()
+        where T5 : new()
+    {
+        public ClassDataSourceAttribute() { }
+        public string[] Keys { get; set; }
+        public .SharedType[] Shared { get; set; }
+        protected override .<<<T1, T2, T3, T4, T5>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public .<string> GetKeys() { }
+        public .<.SharedType> GetSharedTypes() { }
+    }
+    [.DebuggerDisplay("{}")]
+    public class ClassHookContext : .Context
+    {
+        public .AssemblyHookContext AssemblyContext { get; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]
+        public required  ClassType { get; init; }
+        public int TestCount { get; }
+        public .<.TestContext> Tests { get; }
+        public new static .ClassHookContext? Current { get; }
+        public void AddTest(.TestContext testContext) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+    }
+    [.DebuggerDisplay("{Type}")]
+    public class ClassMetadata : .MemberMetadata, <.ClassMetadata>
+    {
+        public ClassMetadata() { }
+        public required .AssemblyMetadata Assembly { get; init; }
+        public <object?[], object>? ConstructorFactory { get; init; }
+        public bool HasRequiredProperties { get; init; }
+        public []? ImplementedInterfaces { get; init; }
+        public <object>? InitializeRequiredProperties { get; init; }
+        public required string? Namespace { get; init; }
+        public <object>? ParameterlessFactory { get; init; }
+        public required .ParameterMetadata[] Parameters { get; init; }
+        public required .ClassMetadata? Parent { get; init; }
+        public required .PropertyMetadata[] Properties { get; init; }
+        public int TestConstructorIndex { get; init; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public override required  Type { get; init; }
+        public required .TypeReference TypeReference { get; init; }
+        public virtual bool Equals(.ClassMetadata? other) { }
+        public override int GetHashCode() { }
+        public static .ClassMetadata GetOrAdd(string name, <.ClassMetadata> factory) { }
+    }
+    public abstract class Context : , .
+    {
+        public .TextWriter ErrorOutputWriter { get; }
+        public .TextWriter OutputWriter { get; }
+        protected .Context? Parent { get; }
+        public static .Context Current { get; }
+        public void AddAsyncLocalValues() { }
+        public void Dispose() { }
+        public . GetDefaultLogger() { }
+        public string GetErrorOutput() { }
+        public string GetStandardOutput() { }
+        public void RestoreExecutionContext() { }
+    }
+    public class ContextProvider : .
+    {
+        public ContextProvider( serviceProvider, string testSessionId, string? testFilter) { }
+        public .BeforeTestDiscoveryContext BeforeTestDiscoveryContext { get; }
+        public .GlobalContext GlobalContext { get; }
+        public .TestDiscoveryContext TestDiscoveryContext { get; }
+        public .TestSessionContext TestSessionContext { get; }
+        public .TestContext CreateTestContext(string testName, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  classType, .TestBuilderContext testBuilderContext, .CancellationToken cancellationToken) { }
+        public .AssemblyHookContext GetOrCreateAssemblyContext(.Assembly assembly) { }
+        public .ClassHookContext GetOrCreateClassContext([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  classType) { }
+    }
+    public class CultureExecutor : .DedicatedThreadExecutor
+    {
+        public CultureExecutor(.CultureInfo cultureInfo) { }
+        protected override void ConfigureThread(.Thread thread) { }
+    }
+    public class DataGenerationException : 
+    {
+        public DataGenerationException(string message) { }
+        public DataGenerationException(string message,  innerException) { }
+        public DataGenerationException(string message, object? dataSource) { }
+        public DataGenerationException(string message, object? dataSource,  innerException) { }
+        public object? DataSource { get; }
+        public string? DataSourceTypeName { get; }
+        public string? TestClassName { get; }
+        public string? TestMethodName { get; }
+        public override string ToString() { }
+        public .DataGenerationException WithTestContext(string? className, string? methodName) { }
+    }
+    public class DataGeneratorMetadata : <.DataGeneratorMetadata>
+    {
+        public DataGeneratorMetadata() { }
+        public required object?[]? ClassInstanceArguments { get; init; }
+        public required .MemberMetadata[] MembersToGenerate { get; init; }
+        public required .TestBuilderContextAccessor TestBuilderContext { get; init; }
+        public required object? TestClassInstance { get; init; }
+        public required .MethodMetadata? TestInformation { get; init; }
+        public required string TestSessionId { get; init; }
+        public required . Type { get; init; }
+    }
+    public sealed class DataSourceContext
+    {
+        public DataSourceContext( testClassType, .DataSourceLevel level, .MemberInfo? targetMember = null, .ParameterInfo? targetParameter = null, .<>? attributes = null, ? serviceProvider = null) { }
+        public .<> Attributes { get; }
+        public .DataSourceLevel Level { get; }
+        public ? ServiceProvider { get; }
+        public .MemberInfo? TargetMember { get; }
+        public .ParameterInfo? TargetParameter { get; }
+        public  TestClassType { get; }
+    }
+    public class DataSourceException : .TestBuilderException
+    {
+        public DataSourceException(string dataSourceName,  innerException) { }
+        public DataSourceException(string dataSourceName, string message) { }
+        public string DataSourceName { get; }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public abstract class DataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T> : .AsyncDataSourceGeneratorAttribute<T>
+    {
+        protected DataSourceGeneratorAttribute() { }
+        protected abstract .<<T>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.DataSourceGeneratorAttribute<T>.<GenerateDataSourcesAsync>d__1))]
+        protected override .<<.<T>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class DataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2> : .AsyncDataSourceGeneratorAttribute<T1, T2>
+    {
+        protected DataSourceGeneratorAttribute() { }
+        protected abstract .<<<T1, T2>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.DataSourceGeneratorAttribute<T1, T2>.<GenerateDataSourcesAsync>d__1))]
+        protected override .<<.<<T1, T2>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class DataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T3> : .AsyncDataSourceGeneratorAttribute<T1, T2, T3>
+    {
+        protected DataSourceGeneratorAttribute() { }
+        protected abstract .<<<T1, T2, T3>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.DataSourceGeneratorAttribute<T1, T2, T3>.<GenerateDataSourcesAsync>d__1))]
+        protected override sealed .<<.<<T1, T2, T3>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class DataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T4> : .AsyncDataSourceGeneratorAttribute<T1, T2, T3, T4>
+    {
+        protected DataSourceGeneratorAttribute() { }
+        protected abstract .<<<T1, T2, T3, T4>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.DataSourceGeneratorAttribute<T1, T2, T3, T4>.<GenerateDataSourcesAsync>d__1))]
+        protected override .<<.<<T1, T2, T3, T4>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public abstract class DataSourceGeneratorAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T1, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T2, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T3, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T4, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods)]  T5> : .AsyncDataSourceGeneratorAttribute<T1, T2, T3, T4, T5>
+    {
+        protected DataSourceGeneratorAttribute() { }
+        protected abstract .<<<T1, T2, T3, T4, T5>>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.DataSourceGeneratorAttribute<T1, T2, T3, T4, T5>.<GenerateDataSourcesAsync>d__1))]
+        protected override .<<.<<T1, T2, T3, T4, T5>>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    public enum DataSourceLevel
+    {
+        Class = 0,
+        Method = 1,
+        Property = 2,
+        Parameter = 3,
+    }
+    public class DedicatedThreadExecutor : .GenericAbstractExecutor, ., .
+    {
+        public DedicatedThreadExecutor() { }
+        protected virtual void CleanUp() { }
+        protected virtual void ConfigureThread(.Thread thread) { }
+        protected override sealed . ExecuteAsync(<.> action) { }
+        protected virtual void Initialize() { }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    public class DefaultExecutor : .GenericAbstractExecutor
+    {
+        public static readonly .DefaultExecutor Instance;
+        protected override . ExecuteAsync(<.> action) { }
+    }
+    [.("DependencyInjectionDataSourceAttribute requires dynamic code generation for depen" +
+        "dency injection container access. This attribute is inherently incompatible with" +
+        " AOT compilation.")]
+    [.("DependencyInjectionDataSourceAttribute may require unreferenced code for dependen" +
+        "cy injection container access. This attribute is inherently incompatible with AO" +
+        "T compilation.")]
+    public abstract class DependencyInjectionDataSourceAttribute<TScope> : .UntypedDataSourceGeneratorAttribute
+    {
+        protected DependencyInjectionDataSourceAttribute() { }
+        public abstract object? Create(TScope scope,  type);
+        public abstract TScope CreateScope(.DataGeneratorMetadata dataGeneratorMetadata);
+        protected override .<<object?[]?>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public class DependsOnAttribute : .TUnitAttribute
+    {
+        public DependsOnAttribute( testClass) { }
+        public DependsOnAttribute(string testName) { }
+        public DependsOnAttribute( testClass, string testName) { }
+        public DependsOnAttribute(string testName, [] parameterTypes) { }
+        public DependsOnAttribute( testClass, string testName, [] parameterTypes) { }
+        public ? ClassMetadata { get; }
+        public []? ParameterTypes { get; }
+        public bool ProceedOnFailure { get; set; }
+        public string? TestName { get; }
+        public override string ToString() { }
+        public .TestDependency ToTestDependency() { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public class DependsOnAttribute<T> : .DependsOnAttribute
+    {
+        public DependsOnAttribute() { }
+        public DependsOnAttribute(string testName) { }
+        public DependsOnAttribute(string testName, [] parameterTypes) { }
+    }
+    public abstract class DiscoveredTest
+    {
+        protected DiscoveredTest() { }
+        public required .TestContext TestContext { get; init; }
+        public .TestDetails TestDetails { get; }
+        public .? TestExecutor { get; set; }
+    }
+    public class DiscoveredTestContext
+    {
+        public DiscoveredTestContext(string testName, .TestContext testContext) { }
+        public .<<object?, string?>> ArgumentDisplayFormatters { get; }
+        public .TestContext TestContext { get; }
+        public .TestDetails TestDetails { get; }
+        public string TestName { get; }
+        public void AddArgumentDisplayFormatter(.ArgumentDisplayFormatter formatter) { }
+        public void AddCategory(string category) { }
+        public void AddParallelConstraint(. constraint) { }
+        public void AddProperty(string key, string value) { }
+        public string GetDisplayName() { }
+        public void SetDisplayName(string displayName) { }
+        public void SetDisplayNameFormatter( formatterType) { }
+        [("Use AddParallelConstraint to support multiple constraints. This method replaces a" +
+            "ll existing constraints.")]
+        public void SetParallelConstraint(. constraint) { }
+        public void SetPriority(. priority) { }
+        public void SetRetryLimit(int retryLimit) { }
+        public void SetRetryLimit(int retryCount, <.TestContext, , int, .<bool>> shouldRetry) { }
+    }
+    public class DiscoveredTest<T> : .DiscoveredTest
+        where T :  class
+    {
+        public DiscoveredTest() { }
+    }
+    public sealed class DiscoveryFailure : <.DiscoveryFailure>
+    {
+        public DiscoveryFailure() { }
+        public required  Exception { get; init; }
+        public string Reason { get; }
+        public string? TestClassName { get; init; }
+        public required string TestFilePath { get; init; }
+        public required string TestId { get; init; }
+        public required int TestLineNumber { get; init; }
+        public required string TestMethodName { get; init; }
+    }
+    public class DiscoveryResult
+    {
+        public DiscoveryResult() { }
+        public static .DiscoveryResult Empty { get; }
+    }
+    [(.Class | .Method, Inherited=false)]
+    public sealed class DisplayNameAttribute : .DisplayNameFormatterAttribute, .IScopedAttribute, .IScopedAttribute<.DisplayNameAttribute>
+    {
+        public DisplayNameAttribute(string displayName) { }
+        protected override string FormatDisplayName(.DiscoveredTestContext context) { }
+    }
+    [(.Assembly | .Class | .Method, Inherited=false)]
+    public abstract class DisplayNameFormatterAttribute : .TUnitAttribute, ., .
+    {
+        protected DisplayNameFormatterAttribute() { }
+        public int Order { get; }
+        protected abstract string FormatDisplayName(.DiscoveredTestContext context);
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    public class DynamicDiscoveryResult : .DiscoveryResult
+    {
+        public DynamicDiscoveryResult() { }
+        public .<> Attributes { get; set; }
+        public string? CreatorFilePath { get; set; }
+        public int? CreatorLineNumber { get; set; }
+        public object?[]? TestClassArguments { get; set; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]
+        public ? TestClassType { get; set; }
+        public .? TestMethod { get; set; }
+        public object?[]? TestMethodArguments { get; set; }
+    }
+    [.("TUnitWIP0001")]
+    public class DynamicTestBuilderAttribute : .BaseTestAttribute
+    {
+        public DynamicTestBuilderAttribute([.] string file = "", [.] int line = 0) { }
+    }
+    public class DynamicTestBuilderContext
+    {
+        public DynamicTestBuilderContext(string filePath, int lineNumber) { }
+        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
+    {
+        public static T Argument<T>() { }
+    }
+    public class DynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T> : .AbstractDynamicTest<T>, .IDynamicTestCreatorLocation
+        where T :  class
+    {
+        public DynamicTest() { }
+        public .<> Attributes { get; set; }
+        public string? CreatorFilePath { get; set; }
+        public int? CreatorLineNumber { get; set; }
+        public object?[]? TestClassArguments { get; set; }
+        public .<<T>>? TestMethod { get; set; }
+        public object?[]? TestMethodArguments { get; set; }
+        public override .<.DiscoveryResult> GetTests() { }
+    }
+    public class EngineCancellationToken : 
+    {
+        public EngineCancellationToken() { }
+        public .CancellationToken Token { get; }
+        public void Dispose() { }
+    }
+    public sealed class ExcludeOnAttribute : .SkipAttribute
+    {
+        public ExcludeOnAttribute(. OperatingSystem) { }
+        public override .<bool> ShouldSkip(.TestRegisteredContext context) { }
+    }
+    public sealed class ExecutableTest : .AbstractExecutableTest
+    {
+        public ExecutableTest(<.TestContext, .<object>> createInstance, <object, object?[], .TestContext, .CancellationToken, .> invokeTest) { }
+        public override .<object> CreateInstanceAsync() { }
+        public override . InvokeTestAsync(object instance, .CancellationToken cancellationToken) { }
+    }
+    public sealed class ExecutableTestCreationContext
+    {
+        public ExecutableTestCreationContext() { }
+        public required object?[] Arguments { get; init; }
+        public required object?[] ClassArguments { get; init; }
+        public required .TestContext Context { get; init; }
+        public required string DisplayName { get; init; }
+        public [] ResolvedClassGenericArguments { get; init; }
+        public [] ResolvedMethodGenericArguments { get; init; }
+        public <.<object>>? TestClassInstanceFactory { get; init; }
+        public required string TestId { get; init; }
+    }
+    [(.Assembly | .Class | .Method)]
+    public class ExecutionPriorityAttribute : .SingleTUnitAttribute, .IScopedAttribute, .IScopedAttribute<.ExecutionPriorityAttribute>, ., .
+    {
+        public ExecutionPriorityAttribute(. priority = 2) { }
+        public int Order { get; }
+        public . Priority { get; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    public class ExpandedTest
+    {
+        public ExpandedTest() { }
+        public object?[]? ClassArguments { get; init; }
+        public bool IsSkipped { get; init; }
+        public object?[]? MethodArguments { get; init; }
+        public required .MethodMetadata MethodMetadata { get; init; }
+        public .<string, object?>? PropertyValues { get; init; }
+        public string? SkipReason { get; init; }
+        public required string TestFilePath { get; init; }
+        public required string TestId { get; init; }
+        public required object TestInstance { get; init; }
+        public required int TestLineNumber { get; init; }
+        public required .MethodInfo TestMethod { get; init; }
+        public required string TestName { get; init; }
+        public ? Timeout { get; init; }
+    }
+    [(.Class | .Method)]
+    public sealed class ExplicitAttribute : .TUnitAttribute
+    {
+        public ExplicitAttribute([.] string callerFile = "", [.] string callerMemberName = "") { }
+        public string For { get; }
+    }
+    public class FailedDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]  T> : .AbstractDynamicTest
+        where T :  class
+    {
+        public FailedDynamicTest() { }
+        public  Exception { get; set; }
+        public string MethodName { get; set; }
+        public string TestFilePath { get; set; }
+        public string TestId { get; set; }
+        public int TestLineNumber { get; set; }
+        public override .<.DiscoveryResult> GetTests() { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public sealed class GenerateGenericTestAttribute : 
+    {
+        public GenerateGenericTestAttribute(params [] typeArguments) { }
+        public [] TypeArguments { get; }
+    }
+    public abstract class GenericAbstractExecutor : ., .
+    {
+        protected GenericAbstractExecutor() { }
+        public int Order { get; }
+        public . ExecuteAfterAssemblyHook(.MethodMetadata hookMethodInfo, .AssemblyHookContext context, <.> action) { }
+        public . ExecuteAfterClassHook(.MethodMetadata hookMethodInfo, .ClassHookContext context, <.> action) { }
+        public . ExecuteAfterTestDiscoveryHook(.MethodMetadata hookMethodInfo, .TestDiscoveryContext context, <.> action) { }
+        public . ExecuteAfterTestHook(.MethodMetadata hookMethodInfo, .TestContext context, <.> action) { }
+        public . ExecuteAfterTestSessionHook(.MethodMetadata hookMethodInfo, .TestSessionContext context, <.> action) { }
+        protected abstract . ExecuteAsync(<.> action);
+        public . ExecuteBeforeAssemblyHook(.MethodMetadata hookMethodInfo, .AssemblyHookContext context, <.> action) { }
+        public . ExecuteBeforeClassHook(.MethodMetadata hookMethodInfo, .ClassHookContext context, <.> action) { }
+        public . ExecuteBeforeTestDiscoveryHook(.MethodMetadata hookMethodInfo, .BeforeTestDiscoveryContext context, <.> action) { }
+        public . ExecuteBeforeTestHook(.MethodMetadata hookMethodInfo, .TestContext context, <.> action) { }
+        public . ExecuteBeforeTestSessionHook(.MethodMetadata hookMethodInfo, .TestSessionContext context, <.> action) { }
+        public . ExecuteTest(.TestContext context, <.> action) { }
+    }
+    public sealed class GenericMethodInfo
+    {
+        public GenericMethodInfo() { }
+        public .GenericParameterConstraints[] Constraints { get; init; }
+        public string[] ParameterNames { get; init; }
+        public int[] ParameterPositions { get; init; }
+    }
+    public sealed class GenericParameterConstraints
+    {
+        public GenericParameterConstraints() { }
+        public ? BaseTypeConstraint { get; init; }
+        public bool HasDefaultConstructorConstraint { get; init; }
+        public bool HasNotNullConstraint { get; init; }
+        public bool HasReferenceTypeConstraint { get; init; }
+        public bool HasValueTypeConstraint { get; init; }
+        public [] InterfaceConstraints { get; init; }
+        public required string ParameterName { get; init; }
+    }
+    public sealed class GenericTestMetadata : .TestMetadata
+    {
+        public GenericTestMetadata() { }
+        public .<string, .TestMetadata>? ConcreteInstantiations { get; init; }
+        public override <.ExecutableTestCreationContext, .TestMetadata, .AbstractExecutableTest> CreateExecutableTestFactory { get; }
+    }
+    public sealed class GenericTypeInfo
+    {
+        public GenericTypeInfo() { }
+        public .GenericParameterConstraints[] Constraints { get; init; }
+        public string[] ParameterNames { get; init; }
+    }
+    public class GlobalContext : .Context
+    {
+        public .TextWriter OriginalConsoleError { get; set; }
+        public .TextWriter OriginalConsoleOut { get; set; }
+        public string? TestFilter { get; }
+        public new static .GlobalContext Current { get; }
+    }
+    public class GlobalSharedDataKey : .SharedDataKey, <.GlobalSharedDataKey>
+    {
+        public static readonly  RandomKey;
+        public GlobalSharedDataKey( Type) { }
+    }
+    public class HookAttribute : .TUnitAttribute
+    {
+        public string File { get; }
+        public .HookType HookType { get; }
+        public int Line { get; }
+        public int Order { get; init; }
+    }
+    public class HookRegisteredContext
+    {
+        public HookRegisteredContext(. hookMethod) { }
+        public . HookMethod { get; }
+        public string HookName { get; }
+        public ? Timeout { get; set; }
+    }
+    public static class HookRegistrationIndices
+    {
+        public static int GetNextAfterAssemblyHookIndex() { }
+        public static int GetNextAfterClassHookIndex() { }
+        public static int GetNextAfterEveryAssemblyHookIndex() { }
+        public static int GetNextAfterEveryClassHookIndex() { }
+        public static int GetNextAfterEveryTestHookIndex() { }
+        public static int GetNextAfterTestDiscoveryHookIndex() { }
+        public static int GetNextAfterTestHookIndex() { }
+        public static int GetNextAfterTestSessionHookIndex() { }
+        public static int GetNextBeforeAssemblyHookIndex() { }
+        public static int GetNextBeforeClassHookIndex() { }
+        public static int GetNextBeforeEveryAssemblyHookIndex() { }
+        public static int GetNextBeforeEveryClassHookIndex() { }
+        public static int GetNextBeforeEveryTestHookIndex() { }
+        public static int GetNextBeforeTestDiscoveryHookIndex() { }
+        public static int GetNextBeforeTestHookIndex() { }
+        public static int GetNextBeforeTestSessionHookIndex() { }
+    }
+    public enum HookType
+    {
+        Test = 0,
+        Class = 1,
+        Assembly = 2,
+        TestSession = 3,
+        TestDiscovery = 4,
+    }
+    public interface IAccessesInstanceData { }
+    public interface IDataSourceAttribute
+    {
+        .<<.<object?[]?>>> GetDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+    }
+    public interface IDynamicTestCreatorLocation
+    {
+        string? CreatorFilePath { get; set; }
+        int? CreatorLineNumber { get; set; }
+    }
+    public interface IDynamicTestMetadata { }
+    public interface IDynamicTestSource
+    {
+        .<.AbstractDynamicTest> CollectDynamicTests(string sessionId);
+    }
+    public interface IRequiresImmediateInitialization { }
+    public interface IScopedAttribute { }
+    public interface IScopedAttribute<T> : .IScopedAttribute
+        where T :  { }
+    public interface ITestDefinition { }
+    public interface ITypedDataSourceAttribute<T> : .IDataSourceAttribute
+    {
+        .<<.<T>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+    }
+    [(.Class)]
+    public sealed class InheritsTestsAttribute : .TUnitAttribute
+    {
+        public InheritsTestsAttribute() { }
+    }
+    [(.Method, AllowMultiple=true)]
+    public class InstanceMethodDataSourceAttribute : .MethodDataSourceAttribute, .IAccessesInstanceData
+    {
+        public InstanceMethodDataSourceAttribute(string methodNameProvidingDataSource) { }
+    }
+    public class InvalidTestMetadataException : .TestBuilderException
+    {
+        public InvalidTestMetadataException(string message, .TestMetadata metadata) { }
+        public InvalidTestMetadataException(string message, .TestMetadata metadata,  innerException) { }
+    }
+    [(.Parameter)]
+    public class MatrixAttribute : .TUnitAttribute
+    {
+        protected MatrixAttribute() { }
+        public MatrixAttribute(params object?[]? objects) { }
+        public object?[]? Excluding { get; init; }
+        public virtual object?[] GetObjects(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Parameter)]
+    public class MatrixAttribute<T> : .MatrixAttribute, .<T>
+    {
+        public MatrixAttribute(params T?[]? objects) { }
+    }
+    [(.Class | .Method)]
+    [.("MatrixDataSource may process enum types dynamically")]
+    [.("MatrixDataSource uses reflection to access parameter attributes and test metadata" +
+        ". For AOT compatibility, consider using explicit data sources.")]
+    public sealed class MatrixDataSourceAttribute : .UntypedDataSourceGeneratorAttribute, .IAccessesInstanceData
+    {
+        public MatrixDataSourceAttribute() { }
+        [.("Matrix generation may process enum types dynamically")]
+        [.("Matrix generation requires reflection")]
+        protected override .<<object?[]?>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method, AllowMultiple=true)]
+    public class MatrixExclusionAttribute : .TUnitAttribute
+    {
+        public MatrixExclusionAttribute(params object?[]? objects) { }
+        public object?[] Objects { get; }
+    }
+    [(.Parameter)]
+    public class MatrixInstanceMethodAttribute<[.(..None | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]  TClass> : .MatrixMethodAttribute<TClass>, .IAccessesInstanceData
+        where TClass :  class
+    {
+        public MatrixInstanceMethodAttribute(string methodName) { }
+    }
+    [(.Parameter)]
+    public class MatrixMethodAttribute<[.(..None | ..PublicMethods | ..NonPublicMethods)]  TClass> : .MatrixAttribute
+        where TClass :  class
+    {
+        public MatrixMethodAttribute(string methodName) { }
+        public override object?[] GetObjects(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Parameter)]
+    public class MatrixRangeAttribute<T> : .MatrixAttribute<T>
+        where T : .INumber<T>
+    {
+        public MatrixRangeAttribute(T min, T max) { }
+        public MatrixRangeAttribute(T min, T max, T step) { }
+    }
+    public abstract class MemberMetadata : <.MemberMetadata>
+    {
+        protected MemberMetadata() { }
+        public required string Name { get; init; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public abstract  Type { get; init; }
+        public virtual bool Equals(.MemberMetadata? other) { }
+        public override int GetHashCode() { }
+        protected virtual bool PrintMembers(.StringBuilder stringBuilder) { }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public class MethodDataSourceAttribute : , .IDataSourceAttribute
+    {
+        public MethodDataSourceAttribute(string methodNameProvidingDataSource) { }
+        public MethodDataSourceAttribute([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]  classProvidingDataSource, string methodNameProvidingDataSource) { }
+        public object?[] Arguments { get; set; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public ? ClassProvidingDataSource { get; }
+        public <.DataGeneratorMetadata, .<<.<object?[]?>>>>? Factory { get; set; }
+        public string MethodNameProvidingDataSource { get; }
+        [.("Trimming", "IL2072", Justification="Method data sources require runtime discovery. AOT users should use Factory prope" +
+            "rty.")]
+        [.("Trimming", "IL2075", Justification="Method data sources require runtime discovery. AOT users should use Factory prope" +
+            "rty.")]
+        [.(typeof(.MethodDataSourceAttribute.<GetDataRowsAsync>d__17))]
+        public .<<.<object?[]?>>> GetDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    public class MethodDataSourceAttribute<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]  T> : .MethodDataSourceAttribute
+    {
+        public MethodDataSourceAttribute(string methodNameProvidingDataSource) { }
+    }
+    [.DebuggerDisplay("{Type}.{Name}")]
+    public class MethodMetadata : .MemberMetadata, <.MethodMetadata>
+    {
+        public MethodMetadata() { }
+        public required .ClassMetadata Class { get; init; }
+        public required int GenericTypeCount { get; init; }
+        public required .ParameterMetadata[] Parameters { get; init; }
+        public ? ReturnType { get; init; }
+        public required .TypeReference ReturnTypeReference { get; init; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public override required  Type { get; init; }
+        public required .TypeReference TypeReference { get; init; }
+        public virtual bool Equals(.MethodMetadata? other) { }
+        public override int GetHashCode() { }
+        protected override bool PrintMembers(.StringBuilder stringBuilder) { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public class NotInParallelAttribute : .SingleTUnitAttribute, .IScopedAttribute, .IScopedAttribute<.NotInParallelAttribute>, ., .
+    {
+        public NotInParallelAttribute() { }
+        public NotInParallelAttribute(string constraintKey) { }
+        public NotInParallelAttribute(string[] constraintKeys) { }
+        public string[] ConstraintKeys { get; }
+        public int Order { get; init; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    public class NotInParallelConstraint : <.NotInParallelConstraint>, .
+    {
+        public NotInParallelConstraint(.<string> NotInParallelConstraintKeys) { }
+        public .<string> NotInParallelConstraintKeys { get; init; }
+        public int Order { get; set; }
+    }
+    public static class ObjectInitializer
+    {
+        public static . InitializeAsync(object? obj, .CancellationToken cancellationToken = default) { }
+    }
+    public class ParallelGroupAttribute : .TUnitAttribute, ., .
+    {
+        public ParallelGroupAttribute(string group) { }
+        public string Group { get; }
+        public int Order { get; set; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    public class ParallelGroupConstraint : , <.ParallelGroupConstraint>, <.ParallelGroupConstraint>, .
+    {
+        public ParallelGroupConstraint(string Group, int Order) { }
+        public string Group { get; init; }
+        public int Order { get; init; }
+        public int CompareTo(.ParallelGroupConstraint? other) { }
+        public int CompareTo(object? obj) { }
+        public virtual bool Equals(.ParallelGroupConstraint? other) { }
+        public override int GetHashCode() { }
+    }
+    public class ParallelLimitLockProvider
+    {
+        public ParallelLimitLockProvider() { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public sealed class ParallelLimiterAttribute<TParallelLimit> : .TUnitAttribute, ., .
+        where TParallelLimit : ., new ()
+    {
+        public ParallelLimiterAttribute() { }
+        public int Order { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    [.DebuggerDisplay("{Type} {Name}")]
+    public class ParameterMetadata : .MemberMetadata, <.ParameterMetadata>
+    {
+        public ParameterMetadata([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]  Type) { }
+        public object? CachedDefaultValue { get; init; }
+        public bool? CachedIsOptional { get; init; }
+        public bool? CachedIsParams { get; init; }
+        public object? DefaultValue { get; }
+        public bool IsNullable { get; init; }
+        public bool IsOptional { get; }
+        public bool IsParams { get; }
+        public int Position { get; init; }
+        public required .ParameterInfo ReflectionInfo { get; set; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public override  Type { get; init; }
+        public required .TypeReference TypeReference { get; init; }
+    }
+    [.DebuggerDisplay("{Type} {Name}")]
+    public class ParameterMetadata<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]  T> : .ParameterMetadata, <.ParameterMetadata<T>>
+    {
+        public ParameterMetadata() { }
+    }
+    [(.Assembly | .Class | .Method, AllowMultiple=true)]
+    public class PropertyAttribute : .TUnitAttribute, ., .
+    {
+        public PropertyAttribute(string name, string value) { }
+        public string Name { get; }
+        public int Order { get; }
+        public string Value { get; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    public sealed class PropertyDataSource
+    {
+        public PropertyDataSource() { }
+        public required .IDataSourceAttribute DataSource { get; init; }
+        public required string PropertyName { get; init; }
+        public required  PropertyType { get; init; }
+    }
+    public sealed class PropertyInjectionData
+    {
+        public PropertyInjectionData() { }
+        public .PropertyInjectionData[] NestedPropertyInjections { get; init; }
+        public <object?, .<string, object?>>? NestedPropertyValueFactory { get; init; }
+        public required string PropertyName { get; init; }
+        public required  PropertyType { get; init; }
+        public required <object, object?> Setter { get; init; }
+        public required <object?> ValueFactory { get; init; }
+    }
+    public class PropertyInjectionException : .TestBuilderException
+    {
+        public PropertyInjectionException(string propertyName,  propertyType,  innerException) { }
+        public string PropertyName { get; }
+        public  PropertyType { get; }
+    }
+    [.DebuggerDisplay("{Type} {Name})")]
+    public class PropertyMetadata : .MemberMetadata, <.PropertyMetadata>
+    {
+        public PropertyMetadata() { }
+        public required .ClassMetadata ClassMetadata { get; set; }
+        public required .ClassMetadata ContainingTypeMetadata { get; set; }
+        public <.IDataSourceAttribute>? CreateDataSource { get; init; }
+        public required <object?, object?> Getter { get; init; }
+        public bool IsInitOnly { get; init; }
+        public bool IsNullable { get; init; }
+        public bool IsRequired { get; init; }
+        public required bool IsStatic { get; init; }
+        public required .PropertyInfo ReflectionInfo { get; init; }
+        public <object, object?>? Setter { get; init; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public override required  Type { get; init; }
+    }
+    public static class PropertySourceRegistry
+    {
+        [.("Reflection discovery is used when source-generated metadata is not available")]
+        public static .PropertyInjectionData[] DiscoverInjectableProperties([.(..None | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  type) { }
+        [return: .(new string[] {
+                "Type",
+                "Source"})]
+        public static .<<, ..IPropertySource>> GetAllSources() { }
+        public static .PropertyDataSource[]? GetPropertyDataSources( type) { }
+        public static .PropertyInjectionData[]? GetPropertyInjectionData( type) { }
+        public static ..IPropertySource? GetSource( type) { }
+        public static void Register( type, ..IPropertySource source) { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public sealed class RepeatAttribute : .TUnitAttribute, .IScopedAttribute, .IScopedAttribute<.RepeatAttribute>
+    {
+        public RepeatAttribute(int times) { }
+        public int Times { get; }
+    }
+    public sealed class ResolvedDependency
+    {
+        public ResolvedDependency() { }
+        public required .TestDependency Metadata { get; init; }
+        public bool ProceedOnFailure { get; }
+        public required .AbstractExecutableTest Test { get; init; }
+    }
+    [(.Assembly | .Class | .Method)]
+    public class RetryAttribute : .TUnitAttribute, .IScopedAttribute, .IScopedAttribute<.RetryAttribute>, ., .
+    {
+        public RetryAttribute(int times) { }
+        public int Order { get; }
+        public int Times { get; }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+        public virtual .<bool> ShouldRetry(.TestContext context,  exception, int currentRetryCount) { }
+    }
+    public sealed class RunOnAttribute : .SkipAttribute
+    {
+        public RunOnAttribute(. OperatingSystem) { }
+        public override .<bool> ShouldSkip(.TestRegisteredContext context) { }
+    }
+    [.("windows")]
+    public class STAThreadExecutor : .DedicatedThreadExecutor
+    {
+        public STAThreadExecutor() { }
+        protected override void ConfigureThread(.Thread thread) { }
+    }
+    public class SharedDataKey : <.SharedDataKey>
+    {
+        public SharedDataKey(string Key,  Type) { }
+        public string Key { get; init; }
+        public  Type { get; init; }
+    }
+    public enum SharedType
+    {
+        None = 0,
+        PerClass = 1,
+        PerAssembly = 2,
+        PerTestSession = 3,
+        Keyed = 4,
+    }
+    public class SingleTUnitAttribute : .TUnitAttribute { }
+    public static class Skip
+    {
+        [.]
+        public static void Test(string reason) { }
+        public static void Unless([.(false)] bool condition, string reason) { }
+        public static void When([.(true)] bool condition, string reason) { }
+    }
+    [(.Assembly | .Class | .Method, AllowMultiple=true)]
+    public class SkipAttribute : , ., .
+    {
+        public SkipAttribute(string reason) { }
+        public int Order { get; }
+        public string Reason { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+        public virtual .<bool> ShouldSkip(.TestRegisteredContext context) { }
+    }
+    [.StackTraceHidden]
+    public class SourceRegistrar
+    {
+        public SourceRegistrar() { }
+        public static bool IsEnabled { get; set; }
+        public static void Register(..ITestSource testSource) { }
+        public static void Register( testClassType, ..ITestSource testSource) { }
+        public static void RegisterAssembly(<.Assembly> assemblyLoader) { }
+        public static void RegisterDynamic(.IDynamicTestSource testSource) { }
+        public static void RegisterGlobalInitializer(<.> initializer) { }
+        public static void RegisterProperty(..IPropertySource propertySource) { }
+    }
+    public static class Sources
+    {
+        public static readonly .<.Assembly, .<.>> AfterAssemblyHooks;
+        public static readonly .<, .<.>> AfterClassHooks;
+        public static readonly .<.> AfterEveryAssemblyHooks;
+        public static readonly .<.> AfterEveryClassHooks;
+        public static readonly .<.> AfterEveryTestHooks;
+        public static readonly .<.> AfterTestDiscoveryHooks;
+        public static readonly .<, .<.>> AfterTestHooks;
+        public static readonly .<.> AfterTestSessionHooks;
+        public static readonly .<<.Assembly>> AssemblyLoaders;
+        public static readonly .<.Assembly, .<.>> BeforeAssemblyHooks;
+        public static readonly .<, .<.>> BeforeClassHooks;
+        public static readonly .<.> BeforeEveryAssemblyHooks;
+        public static readonly .<.> BeforeEveryClassHooks;
+        public static readonly .<.> BeforeEveryTestHooks;
+        public static readonly .<.> BeforeTestDiscoveryHooks;
+        public static readonly .<, .<.>> BeforeTestHooks;
+        public static readonly .<.> BeforeTestSessionHooks;
+        public static readonly .<.IDynamicTestSource> DynamicTestSources;
+        public static readonly .<<.>> GlobalInitializers;
+        public static readonly .<..IPropertySource> PropertySources;
+        public static readonly .<, .<..ITestSource>> TestSources;
+    }
+    [.("Reflection mode requires dynamic access for static property initialization")]
+    public static class StaticPropertyReflectionInitializer
+    {
+        [.("Data source initialization may require dynamic code generation")]
+        public static . InitializeAllStaticPropertiesAsync() { }
+        [.("Data source initialization may require dynamic code generation")]
+        public static . InitializeStaticPropertiesForType( type) { }
+    }
+    public class TUnitAttribute :  { }
+    [(.Method)]
+    public sealed class TestAttribute : .BaseTestAttribute
+    {
+        public TestAttribute([.] string file = "", [.] int line = 0) { }
+    }
+    public class TestBuilderContext : <.TestBuilderContext>
+    {
+        public TestBuilderContext() { }
+        public .IDataSourceAttribute? DataSourceAttribute { get; set; }
+        public .TestContextEvents Events { get; set; }
+        public  Id { get; }
+        public .<string, object?> ObjectBag { get; set; }
+        public required .MethodMetadata TestMetadata { get; init; }
+        public static .TestBuilderContext? Current { get; }
+        public void RegisterForInitialization(object? obj) { }
+    }
+    public class TestBuilderContextAccessor
+    {
+        public TestBuilderContextAccessor(.TestBuilderContext context) { }
+        public .TestBuilderContext Current { get; set; }
+    }
+    public class TestBuilderException : 
+    {
+        public TestBuilderException() { }
+        public TestBuilderException(string message) { }
+        public TestBuilderException(string message,  innerException) { }
+        public .<string, object?> Context { get; set; }
+        public .TestMetadata? TestMetadata { get; set; }
+    }
+    [(.Constructor)]
+    public sealed class TestConstructorAttribute : .TUnitAttribute
+    {
+        public TestConstructorAttribute() { }
+    }
+    [.DebuggerDisplay("{.Name}.{GetDisplayName(),nq}")]
+    public class TestContext : .Context
+    {
+        public TestContext(string testName,  serviceProvider, .ClassHookContext classContext, .TestBuilderContext testBuilderContext, .CancellationToken cancellationToken) { }
+        public .<<object?, string?>> ArgumentDisplayFormatters { get; }
+        public .<.Artifact> Artifacts { get; }
+        public .CancellationToken CancellationToken { get; set; }
+        public .ClassHookContext ClassContext { get; }
+        public int CurrentRetryAttempt { get; }
+        public .<.TestDetails> Dependencies { get; }
+        public ? DisplayNameFormatter { get; set; }
+        public .TestContextEvents Events { get; }
+        public . ExecutionPriority { get; set; }
+        public  Id { get; }
+        public .CancellationTokenSource? LinkedCancellationTokens { get; set; }
+        public object Lock { get; }
+        public .<string, object?> ObjectBag { get; }
+        [("Use ParallelConstraints collection instead. This property is maintained for backw" +
+            "ard compatibility.")]
+        public .? ParallelConstraint { get; set; }
+        public .<.> ParallelConstraints { get; }
+        public .? ParallelLimiter { get; }
+        public .TestPhase Phase { get; set; }
+        public bool ReportResult { get; set; }
+        public .TestResult? Result { get; set; }
+        public <.TestContext, , int, .<bool>>? RetryFunc { get; set; }
+        public string? SkipReason { get; set; }
+        public .TestDetails TestDetails { get; set; }
+        public ? TestEnd { get; set; }
+        public string TestName { get; }
+        public ? TestStart { get; set; }
+        public .<.Timing> Timings { get; }
+        public static . Configuration { get; }
+        public new static .TestContext? Current { get; }
+        public static string? OutputDirectory { get; }
+        public static .<string, .<string>> Parameters { get; }
+        public static string WorkingDirectory { get; set; }
+        public void AddArtifact(.Artifact artifact) { }
+        public void AddLinkedCancellationToken(.CancellationToken cancellationToken) { }
+        public void AddParallelConstraint(. constraint) { }
+        public string GetDisplayName() { }
+        public new string GetErrorOutput() { }
+        public string GetOutput() { }
+        public T? GetService<T>()
+            where T :  class { }
+        public .<.TestContext> GetTests(<.TestContext, bool> predicate) { }
+        public .<.TestContext> GetTests(string testName) { }
+        public .<.TestContext> GetTests(string testName,  classType) { }
+        public void OverrideResult(string reason) { }
+        public void OverrideResult(.TestState state, string reason) { }
+        [("This method is non-functional after the removal of ITestFinder. It will be remove" +
+            "d in a future version.")]
+        public . ReregisterTestWithArguments(object?[]? methodArguments = null, .<string, object?>? objectBag = null) { }
+        public void SetParallelLimiter(. parallelLimit) { }
+        public void WriteError(string message) { }
+        public void WriteLine(string message) { }
+        public static .TestContext? GetById( id) { }
+    }
+    public class TestContextEvents
+    {
+        public TestContextEvents() { }
+        public .AsyncEvent<.TestContext>? OnDispose { get; set; }
+        public .AsyncEvent<.TestContext>? OnInitialize { get; set; }
+        public .AsyncEvent<.TestContext>? OnTestEnd { get; set; }
+        public .AsyncEvent<.TestContext>? OnTestRegistered { get; set; }
+        [.(new string[] {
+                null,
+                "RetryAttempt"})]
+        public .AsyncEvent<<.TestContext, int>>? OnTestRetry { get; set; }
+        public .AsyncEvent<.TestContext>? OnTestSkipped { get; set; }
+        public .AsyncEvent<.TestContext>? OnTestStart { get; set; }
+    }
+    public class TestDataCombination
+    {
+        public TestDataCombination() { }
+        public <.<object?>>[] ClassDataFactories { get; init; }
+        public int ClassDataSourceIndex { get; init; }
+        public int ClassLoopIndex { get; init; }
+        public ? DataGenerationException { get; init; }
+        public string? DisplayName { get; init; }
+        public <.<object?>>[] MethodDataFactories { get; init; }
+        public int MethodDataSourceIndex { get; init; }
+        public int MethodLoopIndex { get; init; }
+        public int RepeatIndex { get; init; }
+        public .<string, >? ResolvedGenericTypes { get; init; }
+    }
+    public class TestDefinition : .ITestDefinition
+    {
+        public TestDefinition() { }
+    }
+    public class TestDefinition<T> : .TestDefinition
+        where T :  class
+    {
+        public TestDefinition() { }
+    }
+    public sealed class TestDependency : <.TestDependency>
+    {
+        public TestDependency() { }
+        public int ClassGenericArity { get; init; }
+        public ? ClassType { get; init; }
+        public int MethodGenericArity { get; init; }
+        public string? MethodName { get; init; }
+        public []? MethodParameters { get; init; }
+        public bool ProceedOnFailure { get; init; }
+        public bool Equals(.TestDependency? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public bool Matches(.TestMetadata test, .TestMetadata? dependentTest = null) { }
+        public override string ToString() { }
+        public static .TestDependency FromClass( classType, bool proceedOnFailure = false) { }
+        public static .TestDependency FromClassAndMethod( classType, string methodName, bool proceedOnFailure = false) { }
+        public static .TestDependency FromMethodName(string methodName, bool proceedOnFailure = false) { }
+    }
+    public class TestDetails
+    {
+        public TestDetails() { }
+        public required .<> Attributes { get; init; }
+        public .<string> Categories { get; }
+        public [] ClassGenericArguments { get; set; }
+        public required object ClassInstance { get; set; }
+        public object?[] ClassMetadataArguments { get; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]
+        public required  ClassType { get; init; }
+        public .<string, .<string>> CustomProperties { get; }
+        public [] MethodGenericArguments { get; set; }
+        public required .MethodMetadata MethodMetadata { get; set; }
+        public required string MethodName { get; init; }
+        public int RetryLimit { get; set; }
+        public required  ReturnType { get; set; }
+        public required object?[] TestClassArguments { get; set; }
+        public .<string, object?> TestClassInjectedPropertyArguments { get; init; }
+        public []? TestClassParameterTypes { get; set; }
+        public string TestFilePath { get; set; }
+        public required string TestId { get; init; }
+        public int TestLineNumber { get; set; }
+        public required object?[] TestMethodArguments { get; set; }
+        public required string TestName { get; init; }
+        public ? Timeout { get; set; }
+    }
+    public class TestDetails<T> : .TestDetails
+        where T :  class
+    {
+        public TestDetails() { }
+    }
+    public class TestDiscoveryContext : .Context
+    {
+        public .<.TestContext> AllTests { get; }
+        public .<.AssemblyHookContext> Assemblies { get; }
+        public .BeforeTestDiscoveryContext BeforeTestDiscoveryContext { get; }
+        public .<.ClassHookContext> TestClasses { get; }
+        public required string? TestFilter { get; init; }
+        public new static .TestDiscoveryContext? Current { get; }
+        public void AddTests(.<.TestContext> tests) { }
+    }
+    public class TestInstantiationException : .TestBuilderException
+    {
+        public TestInstantiationException( testClassType,  innerException) { }
+        public TestInstantiationException( testClassType, string message) { }
+        public  TestClassType { get; }
+    }
+    public abstract class TestMetadata
+    {
+        protected TestMetadata() { }
+        public required <[]> AttributeFactory { get; init; }
+        public required .IDataSourceAttribute[] ClassDataSources { get; init; }
+        public abstract <.ExecutableTestCreationContext, .TestMetadata, .AbstractExecutableTest> CreateExecutableTestFactory { get; }
+        public required .IDataSourceAttribute[] DataSources { get; init; }
+        public .TestDependency[] Dependencies { get; init; }
+        public required string FilePath { get; init; }
+        public .GenericMethodInfo? GenericMethodInfo { get; init; }
+        public []? GenericMethodTypeArguments { get; init; }
+        public .GenericTypeInfo? GenericTypeInfo { get; init; }
+        public int InheritanceDepth { get; set; }
+        public <[], object?[], object> InstanceFactory { get; init; }
+        public required int LineNumber { get; init; }
+        public required .MethodMetadata MethodMetadata { get; init; }
+        public required .PropertyDataSource[] PropertyDataSources { get; init; }
+        public .PropertyInjectionData[] PropertyInjections { get; init; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]
+        public required  TestClassType { get; init; }
+        public <object, object?[], .>? TestInvoker { get; init; }
+        public required string TestMethodName { get; init; }
+        public required string TestName { get; init; }
+        public string TestSessionId { get; set; }
+    }
+    public class TestMetadata<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  T> : .TestMetadata, .
+        where T :  class
+    {
+        public TestMetadata() { }
+        public override <.ExecutableTestCreationContext, .TestMetadata, .AbstractExecutableTest> CreateExecutableTestFactory { get; }
+        public new <[], object?[], T>? InstanceFactory { get; init; }
+        public <T, object?[], .CancellationToken, .>? InvokeTypedTest { get; init; }
+        public new <T, object?[], .>? TestInvoker { get; init; }
+        public void UseRuntimeDataGeneration(string testSessionId) { }
+    }
+    public enum TestPhase
+    {
+        Discovery = 0,
+        Registration = 1,
+        BeforeTest = 2,
+        Execution = 3,
+        AfterTest = 4,
+    }
+    public class TestRegisteredContext
+    {
+        public TestRegisteredContext(.TestContext testContext) { }
+        public string? CustomDisplayName { get; }
+        public .DiscoveredTest DiscoveredTest { get; set; }
+        public .<string, object?> ObjectBag { get; }
+        public .TestContext TestContext { get; }
+        public .TestDetails TestDetails { get; }
+        public string TestName { get; }
+        public void SetParallelLimiter(. parallelLimit) { }
+        public void SetTestExecutor(. executor) { }
+    }
+    public class TestResult : <.TestResult>
+    {
+        public TestResult() { }
+        public required string ComputerName { get; init; }
+        public required ? Duration { get; init; }
+        public required ? End { get; init; }
+        public required ? Exception { get; init; }
+        public bool IsOverridden { get; set; }
+        public string? Output { get; }
+        public string? OverrideReason { get; set; }
+        public required ? Start { get; init; }
+        public required .TestState State { get; init; }
+    }
+    public class TestSessionContext : .Context
+    {
+        public .<.TestContext> AllTests { get; }
+        public .<.AssemblyHookContext> Assemblies { get; }
+        public required string Id { get; init; }
+        public .<.ClassHookContext> TestClasses { get; }
+        public .TestDiscoveryContext TestDiscoveryContext { get; }
+        public required string? TestFilter { get; init; }
+        public new static .TestSessionContext? Current { get; }
+        public static .TestBuilderContext GlobalStaticPropertyContext { get; }
+        public void AddArtifact(.Artifact artifact) { }
+        public void AddAssembly(.AssemblyHookContext assemblyHookContext) { }
+    }
+    public enum TestState
+    {
+        NotStarted = 0,
+        WaitingForDependencies = 1,
+        Queued = 2,
+        Running = 3,
+        Passed = 4,
+        Failed = 5,
+        Skipped = 6,
+        Timeout = 7,
+        Cancelled = 8,
+    }
+    public static class TestStateExtensions
+    {
+        public static bool IsFailure(this .TestState state) { }
+        public static bool IsFinal(this .TestState state) { }
+        public static bool IsSuccess(this .TestState state) { }
+        public static bool IsTransient(this .TestState state) { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public class TimeoutAttribute : .TUnitAttribute, .IScopedAttribute, .IScopedAttribute<.TimeoutAttribute>, ., ., .
+    {
+        public TimeoutAttribute(int timeoutInMilliseconds) { }
+        public int Order { get; }
+        public  Timeout { get; }
+        public . OnHookRegistered(.HookRegisteredContext context) { }
+        public . OnTestDiscovered(.DiscoveredTestContext context) { }
+    }
+    public class Timing : <.Timing>
+    {
+        public Timing(string StepName,  Start,  End) { }
+        public  Duration { get; }
+        public  End { get; init; }
+        public  Start { get; init; }
+        public string StepName { get; init; }
+    }
+    public sealed class TypeArrayComparer : .<[]>
+    {
+        public static readonly .TypeArrayComparer Instance;
+        public bool Equals([]? x, []? y) { }
+        public int GetHashCode([] obj) { }
+    }
+    public sealed class TypeReference
+    {
+        public TypeReference() { }
+        public int ArrayRank { get; set; }
+        public string? AssemblyQualifiedName { get; set; }
+        public .TypeReference? ElementType { get; set; }
+        public .<.TypeReference> GenericArguments { get; set; }
+        public string? GenericParameterName { get; set; }
+        public int GenericParameterPosition { get; set; }
+        public bool IsArray { get; set; }
+        public bool IsByRef { get; set; }
+        public bool IsGenericParameter { get; set; }
+        public bool IsMethodGenericParameter { get; set; }
+        public bool IsPointer { get; set; }
+        public static .TypeReference CreateArray(.TypeReference elementType, int rank = 1) { }
+        public static .TypeReference CreateConcrete(string assemblyQualifiedName) { }
+        public static .TypeReference CreateConstructedGeneric(string genericTypeDefinition, params .TypeReference[] genericArguments) { }
+        public static .TypeReference CreateGenericParameter(int position, bool isMethodParameter, string? name = null) { }
+    }
+    public static class TypeRegistry
+    {
+        public static .<string, > GetAllRegisteredTypes() { }
+        public static void RegisterArrayType( elementType, int rank,  arrayType) { }
+        public static void RegisterByRefType( elementType,  byRefType) { }
+        public static void RegisterConstructedGenericType( genericDefinition, [] genericArguments,  constructedType) { }
+        public static void RegisterPointerType( elementType,  pointerType) { }
+        public static void RegisterType(string assemblyQualifiedName,  type) { }
+    }
+    public sealed class TypeResolver
+    {
+        public TypeResolver(? declaringType = null, .MethodInfo? declaringMethod = null) { }
+        public  Resolve(.TypeReference typeReference) { }
+        public [] ResolveMany(.<.TypeReference> typeReferences) { }
+        public static .TypeResolver CreateSimple() { }
+        public static .TypeResolver FromTestInstance(object testInstance, .MethodInfo? testMethod = null) { }
+    }
+    public abstract class TypedDataSourceAttribute<T> : , .IDataSourceAttribute, .ITypedDataSourceAttribute<T>
+    {
+        protected TypedDataSourceAttribute() { }
+        [.(typeof(.TypedDataSourceAttribute<T>.<GetDataRowsAsync>d__1))]
+        public .<<.<object?[]?>>> GetDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+        public abstract .<<.<T>>> GetTypedDataRowsAsync(.DataGeneratorMetadata dataGeneratorMetadata);
+    }
+    [(.Class | .Method | .Property, AllowMultiple=true)]
+    [.("UntypedDataSourceGeneratorAttribute requires dynamic code generation for runtime " +
+        "data source creation. Consider using strongly-typed AsyncDataSourceGeneratorAttr" +
+        "ibute<T> overloads for AOT compatibility.")]
+    [.("UntypedDataSourceGeneratorAttribute may require unreferenced code for runtime dat" +
+        "a source creation. Consider using strongly-typed AsyncDataSourceGeneratorAttribu" +
+        "te<T> overloads for AOT compatibility.")]
+    public abstract class UntypedDataSourceGeneratorAttribute : .AsyncUntypedDataSourceGeneratorAttribute
+    {
+        protected UntypedDataSourceGeneratorAttribute() { }
+        protected abstract .<<object?[]?>> GenerateDataSources(.DataGeneratorMetadata dataGeneratorMetadata);
+        [.(typeof(.UntypedDataSourceGeneratorAttribute.<GenerateDataSourcesAsync>d__1))]
+        protected override sealed .<<.<object?[]?>>> GenerateDataSourcesAsync(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+}
+namespace .AotCompatibility
+{
+    public enum AotCompatibilityMode
+    {
+        SourceGenerated = 0,
+        ManuallyRegistered = 1,
+        ConcreteTypesOnly = 2,
+        TupleInterfaceBased = 3,
+    }
+    [(.Method)]
+    public class AotCompatibleAttribute : 
+    {
+        public AotCompatibleAttribute() { }
+        public string? Details { get; init; }
+        public . Mode { get; init; }
+    }
+    public static class GenericTestRegistry
+    {
+        public static .MethodInfo? GetCompiledMethod( declaringType, string methodName, [] typeArguments) { }
+        public static TDelegate? GetDirectDelegate<TDelegate>( declaringType, string methodName, [] typeArguments)
+            where TDelegate :  { }
+        public static .<[]> GetRegisteredCombinations( declaringType) { }
+        public static bool IsMarkedAotCompatible(.MethodInfo method) { }
+        public static bool IsRegistered( declaringType, string methodName, [] typeArguments) { }
+        public static void MarkAsAotCompatible(.MethodInfo method) { }
+        public static void RegisterDirectDelegate<T>( declaringType, string methodName, [] typeArguments, T delegateInstance)
+            where T :  { }
+        public static void RegisterGenericMethod( declaringType, string methodName, [] typeArguments, .MethodInfo compiledMethod) { }
+    }
+}
+namespace .Attributes
+{
+    [(.Class | .Constructor | .Method | .Property)]
+    public sealed class AotCompatibleAttribute : 
+    {
+        public AotCompatibleAttribute() { }
+        public string? AlternativeForReflection { get; set; }
+        public string? Notes { get; set; }
+    }
+    [(.Class | .Constructor | .Method | .Property)]
+    public sealed class RequiresReflectionAttribute : 
+    {
+        public RequiresReflectionAttribute(string reason) { }
+        public string? AotAlternative { get; set; }
+        public string Reason { get; }
+    }
+}
+namespace .Converters
+{
+    public static class AotConverterRegistry
+    {
+        public static void Register(. converter) { }
+        public static bool TryConvert( sourceType,  targetType, object? value, out object? result) { }
+        public static bool TryGetConverter( sourceType,  targetType, out .? converter) { }
+    }
+    public interface IAotConverter
+    {
+         SourceType { get; }
+         TargetType { get; }
+        object? Convert(object? value);
+    }
+}
+namespace .Data
+{
+    public class ScopedDictionary<TScope>
+        where TScope :  notnull
+    {
+        public ScopedDictionary() { }
+        public object? GetOrCreate(TScope scope,  type, <, object?> factory) { }
+    }
+    public class ThreadSafeDictionary<TKey, [.(..PublicParameterlessConstructor)]  TValue>
+        where TKey :  notnull
+    {
+        public ThreadSafeDictionary() { }
+        public TValue this[TKey key] { get; }
+        public .<TKey> Keys { get; }
+        public .<TValue> Values { get; }
+        public TValue GetOrAdd(TKey key, <TKey, TValue> func) { }
+        public TValue? Remove(TKey key) { }
+        public bool TryGetValue(TKey key, [.(true)] out TValue? value) { }
+    }
+}
+namespace .DataSources
+{
+    public static class DataSourceProcessor
+    {
+        [.("This method may create types at runtime")]
+        [.("This method uses reflection to process data sources")]
+        public static .<.<object?[]>> ProcessGeneratorItemAsync(object? item) { }
+        [.("This method uses reflection for tuple processing")]
+        public static .<object?[]> ProcessMethodDataSourceResult(object? result) { }
+        public static .<.<object?[]>> ProcessTypedArrayGeneratorItemAsync<T>(<.<T[]>> taskFunc) { }
+        public static .<.<object?[]>> ProcessTypedGeneratorItemAsync<T>(<.<T>> taskFunc) { }
+        public static object? ResolveTypedValue<T>(<T> func) { }
+        public static .<object?> ResolveTypedValueAsync<T>(<.<T>> taskFunc) { }
+        [.("This method may invoke methods dynamically")]
+        [.("This method uses reflection to resolve values")]
+        public static .<object?> ResolveValueAsync(object? value) { }
+    }
+    public static class TestDataFormatter
+    {
+        public static string CreateDisplayName(.TestMetadata metadata, object?[] arguments, .TestDataCombination? dataCombination = null) { }
+        public static string CreateGenericDisplayName(.TestMetadata metadata, [] genericTypes, object?[] arguments) { }
+        public static string FormatArguments(.TestContext context) { }
+        public static string FormatArguments(object?[] arguments) { }
+        public static string FormatArguments(object?[] arguments, .<<object?, string?>> formatters) { }
+    }
+}
+namespace .Enums
+{
+    public enum DataGeneratorType
+    {
+        ClassParameters = 0,
+        TestParameters = 1,
+        Property = 2,
+    }
+    public enum LogLevel
+    {
+        None = -1,
+        Trace = 0,
+        Debug = 1,
+        Information = 2,
+        Warning = 3,
+        Error = 4,
+        Critical = 5,
+    }
+    []
+    public enum OS
+    {
+        Linux = 1,
+        Windows = 2,
+        MacOs = 4,
+        Browser = 8,
+    }
+    public enum Priority
+    {
+        Low = 0,
+        BelowNormal = 1,
+        Normal = 2,
+        AboveNormal = 3,
+        High = 4,
+        Critical = 5,
+    }
+}
+namespace .Events
+{
+    []
+    public enum EventType
+    {
+        Initialize = 1,
+        Dispose = 2,
+        TestRegistered = 4,
+        TestStart = 8,
+        TestEnd = 16,
+        TestSkipped = 32,
+        FirstTestInClass = 64,
+        FirstTestInAssembly = 128,
+        FirstTestInTestSession = 256,
+        LastTestInClass = 512,
+        LastTestInAssembly = 1024,
+        LastTestInTestSession = 2048,
+        TestRetry = 2049,
+        All = 4095,
+    }
+}
+namespace .Exceptions
+{
+    public class AfterAssemblyException : .
+    {
+        public AfterAssemblyException(string message,  innerException) { }
+    }
+    public class AfterClassException : .
+    {
+        public AfterClassException(string message,  innerException) { }
+    }
+    public class AfterTestDiscoveryException : .
+    {
+        public AfterTestDiscoveryException(string message,  innerException) { }
+    }
+    public class AfterTestException : .
+    {
+        public AfterTestException(string message,  innerException) { }
+    }
+    public class AfterTestSessionException : .
+    {
+        public AfterTestSessionException(string message,  innerException) { }
+    }
+    public class BeforeAssemblyException : .
+    {
+        public BeforeAssemblyException(string message,  innerException) { }
+    }
+    public class BeforeClassException : .
+    {
+        public BeforeClassException(string message,  innerException) { }
+    }
+    public class BeforeTestDiscoveryException : .
+    {
+        public BeforeTestDiscoveryException(string message,  innerException) { }
+    }
+    public class BeforeTestException : .
+    {
+        public BeforeTestException(string message,  innerException) { }
+    }
+    public class BeforeTestSessionException : .
+    {
+        public BeforeTestSessionException(string message,  innerException) { }
+    }
+    public class CircularDependencyException : 
+    {
+        public CircularDependencyException() { }
+        public CircularDependencyException(string message) { }
+        public CircularDependencyException(string message,  innerException) { }
+    }
+    public class DependencyConflictException : . { }
+    public class FailTestException : .
+    {
+        public FailTestException(string reason) { }
+        public string Reason { get; }
+    }
+    public class GenericTypeResolutionException : 
+    {
+        public GenericTypeResolutionException(string message) { }
+        public GenericTypeResolutionException(string message,  innerException) { }
+    }
+    public class InconclusiveTestException : .
+    {
+        public InconclusiveTestException(string message,  exception) { }
+    }
+    public class SkipTestException : .
+    {
+        public SkipTestException(string reason) { }
+        public string Reason { get; }
+    }
+    public class TUnitException : 
+    {
+        public TUnitException() { }
+        public TUnitException(string? message) { }
+        public TUnitException(string? message, ? innerException) { }
+    }
+    public class TestDependencyException : .
+    {
+        public TestDependencyException(string dependencyName, bool proceedOnFailure) { }
+        public string DependencyName { get; }
+        public bool ProceedOnFailure { get; }
+    }
+    public class TestFailedInitializationException : 
+    {
+        public TestFailedInitializationException(string? message, ? innerException) { }
+    }
+    public class TestNotExecutedException : . { }
+    public class TestRunCanceledException : .
+    {
+        public TestRunCanceledException() { }
+    }
+    public class TimeoutException : . { }
+}
+namespace .Executors
+{
+    [(.Assembly | .Class | .Method)]
+    public class CultureAttribute : .TUnitAttribute, ., .
+    {
+        public CultureAttribute(.CultureInfo cultureInfo) { }
+        public CultureAttribute(string cultureName) { }
+        public int Order { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    public class HookExecutorAttribute : .TUnitAttribute
+    {
+        public HookExecutorAttribute( type) { }
+        public  HookExecutorType { get; }
+    }
+    [(.Assembly | .Class | .Method)]
+    public sealed class HookExecutorAttribute<T> : .
+        where T : ., new ()
+    {
+        public HookExecutorAttribute() { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public class InvariantCultureAttribute : .
+    {
+        public InvariantCultureAttribute() { }
+    }
+    [(.Assembly | .Class | .Method)]
+    [.("windows")]
+    public class STAThreadExecutorAttribute : .TUnitAttribute, ., .
+    {
+        public STAThreadExecutorAttribute() { }
+        public int Order { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public sealed class TestExecutorAttribute : .TUnitAttribute, ., .
+    {
+        public TestExecutorAttribute([.(..PublicConstructors)]  type) { }
+        public int Order { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+    [(.Assembly | .Class | .Method)]
+    public sealed class TestExecutorAttribute<T> : .TUnitAttribute, ., .
+        where T : ., new ()
+    {
+        public TestExecutorAttribute() { }
+        public int Order { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+    }
+}
+namespace .Extensions
+{
+    public static class MetadataExtensions
+    {
+        public static  DeclaringType(this .MethodMetadata method) { }
+        public static string DisplayName(this .MethodMetadata method) { }
+        public static .<> GetCustomAttributes(this .MethodMetadata method) { }
+        public static .MethodInfo GetReflectionInfo(this .MethodMetadata method) { }
+        public static bool IsGenericMethodDefinition(this .MethodMetadata method) { }
+        public static string MethodName(this .MethodMetadata method) { }
+    }
+    public static class ReflectionExtensions
+    {
+        public static [] GetCustomAttributesSafe(this .ICustomAttributeProvider provider, bool inherit = true) { }
+        public static T[] GetCustomAttributesSafe<T>(this .ICustomAttributeProvider provider, bool inherit = true)
+            where T :  { }
+    }
+    public static class TestContextExtensions
+    {
+        [.("Adding dynamic tests requires reflection which is not supported in native AOT sce" +
+            "narios.")]
+        [.("Dynamic test metadata creation uses reflection")]
+        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) { }
+        public static T? GetService<T>(this .TestContext context)
+            where T :  class { }
+    }
+}
+namespace .Helpers
+{
+    public static class ArgumentFormatter
+    {
+        public static string Format(object? o, .<<object?, string?>> formatters) { }
+        public static string FormatArguments(.<object?> arguments) { }
+        public static string GetConstantValue(.TestContext testContext, object? o) { }
+    }
+    public static class CastHelper
+    {
+        [.("Dynamic type conversion may require runtime code generation")]
+        [.("Type conversion uses reflection for custom conversions")]
+        public static object? Cast([.(..None | ..PublicMethods | ..NonPublicMethods)]  type, object? value) { }
+        [.("Dynamic type conversion may require runtime code generation")]
+        [.("Type conversion uses reflection for custom conversions")]
+        public static T? Cast<[.(..None | ..PublicMethods | ..NonPublicMethods)]  T>(object? value) { }
+        public static .MethodInfo? GetConversionMethod([.(..None | ..PublicMethods | ..NonPublicMethods)]  baseType, [.(..None | ..PublicMethods | ..NonPublicMethods)]  targetType) { }
+    }
+    public static class ClassConstructorHelper
+    {
+        public static .ClassConstructorAttribute? GetClassConstructorAttribute([] attributes) { }
+        public static bool HasClassConstructorAttribute([] attributes) { }
+        public static .<object?> TryCreateInstanceWithClassConstructor(.<> attributes, [.(..PublicConstructors)]  testClassType, .TestBuilderContext testBuilderContext, string testSessionId) { }
+        public static .<object?> TryCreateInstanceWithClassConstructor(.<> attributes, [.(..PublicConstructors)]  testClassType, string testSessionId, .TestContext testContext) { }
+    }
+    [.DebuggerDisplay("Count = {CurrentCount}")]
+    public class Counter
+    {
+        public Counter() { }
+        public int CurrentCount { get; }
+        public event <int>? OnCountChanged;
+        public int Add(int value) { }
+        public int Decrement() { }
+        public int Increment() { }
+    }
+    public static class DataConversionHelper
+    {
+        [.(typeof(..<ConvertAsyncEnumerableToObjectArrays>d__2<T>))]
+        public static .<object?[]> ConvertAsyncEnumerableToObjectArrays<T>(.<T> source, [.] .CancellationToken ct = default) { }
+        [.(typeof(..<ConvertAsyncEnumerableTuple2ToObjectArrays>d__3<T1?, T2?>?))]
+        public static .<object?[]> ConvertAsyncEnumerableTuple2ToObjectArrays<T1, T2>(.<<T1, T2>> source, [.] .CancellationToken ct = default) { }
+        [.(typeof(..<ConvertAsyncEnumerableTuple3ToObjectArrays>d__4<T1?, T2?, T3?>?))]
+        public static .<object?[]> ConvertAsyncEnumerableTuple3ToObjectArrays<T1, T2, T3>(.<<T1, T2, T3>> source, [.] .CancellationToken ct = default) { }
+        [.(typeof(..<ConvertAsyncEnumerableTuple4ToObjectArrays>d__5<T1?, T2?, T3?, T4?>?))]
+        public static .<object?[]> ConvertAsyncEnumerableTuple4ToObjectArrays<T1, T2, T3, T4>(.<<T1, T2, T3, T4>> source, [.] .CancellationToken ct = default) { }
+        [.(typeof(..<ConvertAsyncEnumerableTuple5ToObjectArrays>d__6<T1?, T2?, T3?, T4?, T5?>?))]
+        public static .<object?[]> ConvertAsyncEnumerableTuple5ToObjectArrays<T1, T2, T3, T4, T5>(.<<T1, T2, T3, T4, T5>> source, [.] .CancellationToken ct = default) { }
+        [.(typeof(..<ConvertToAsyncEnumerableInternal>d__1?))]
+        public static .<object?[]> ConvertToAsyncEnumerableInternal(.<object?[]> data, [.] .CancellationToken ct = default) { }
+        public static .<object?[]> ConvertToObjectArrays(object? data) { }
+        public static object?[] UnwrapTuple(. tuple) { }
+        public static object?[] UnwrapTuple<T1, T2>(<T1, T2> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3>(<T1, T2, T3> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4>(<T1, T2, T3, T4> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5>(<T1, T2, T3, T4, T5> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6>(<T1, T2, T3, T4, T5, T6> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6, T7>(<T1, T2, T3, T4, T5, T6, T7> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6, T7, T8>(<T1, T2, T3, T4, T5, T6, T7, <T8>> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(<T1, T2, T3, T4, T5, T6, T7, <T8, T9>> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(<T1, T2, T3, T4, T5, T6, T7, <T8, T9, T10>> tuple) { }
+        public static .<.<object?[]>> WrapTaskEnumerableAsObjectArrays<T>(.<.<T>> task) { }
+    }
+    public static class DataSourceHelpers
+    {
+        public static <.<object?>>[] HandleTupleValue(object? value, bool shouldUnwrap) { }
+        public static . InitializeDataSourcePropertiesAsync(object? instance, .MethodMetadata testInformation, string testSessionId) { }
+        public static object? InvokeIfFunc(object? value) { }
+        public static T InvokeIfFunc<T>(object? value) { }
+        public static bool IsTuple(object? obj) { }
+        public static .<object?> ProcessDataSourceResult<T>(T data) { }
+        public static .<object?> ProcessDataSourceResultGeneric<T>(T data) { }
+        public static .<object?> ProcessEnumerableDataSource<T>(.<T> enumerable) { }
+        public static <.<object?>>[] ProcessTestDataSource<T>(T data, int expectedParameterCount = -1) { }
+        public static void RegisterPropertyInitializer<T>(<T, .MethodMetadata, string, .> initializer) { }
+        public static void RegisterTypeCreator<T>(<.MethodMetadata, string, .<T>> creator) { }
+        [.("Data source resolution may require dynamic code generation")]
+        [.("Property types are resolved through reflection")]
+        public static .<object?> ResolveDataSourceForPropertyAsync([.(..None | ..PublicParameterlessConstructor | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  containingType, string propertyName, .MethodMetadata testInformation, string testSessionId) { }
+        public static .<object?> ResolveDataSourcePropertyAsync(object instance, string propertyName, .MethodMetadata testInformation, string testSessionId) { }
+        public static object?[] ToObjectArray(this object? item) { }
+        public static object?[] ToObjectArrayWithTypes(this object? item, []? expectedTypes) { }
+        [return: .(new string[] {
+                "success",
+                "createdInstance"})]
+        public static .<<bool, object?>> TryCreateWithInitializerAsync( type, .MethodMetadata testInformation, string testSessionId) { }
+        public static object?[] UnwrapTuple<T1>(<T1> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2>(<T1, T2> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3>(<T1, T2, T3> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4>(<T1, T2, T3, T4> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5>(<T1, T2, T3, T4, T5> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6>(<T1, T2, T3, T4, T5, T6> tuple) { }
+        public static object?[] UnwrapTuple<T1, T2, T3, T4, T5, T6, T7>(<T1, T2, T3, T4, T5, T6, T7> tuple) { }
+        public static object?[] UnwrapTupleAot(object? value) { }
+    }
+    public static class DecimalParsingHelper
+    {
+        public static decimal ParseDecimalWithCultureFallback(string value) { }
+    }
+    public static class GenericTypeHelper
+    {
+        public static  GetGenericTypeDefinition( type) { }
+        public static bool IsConstructedGenericType( type) { }
+        [.("MakeGenericType requires runtime code generation")]
+        public static  MakeGenericTypeSafe( genericTypeDefinition, params [] typeArguments) { }
+    }
+    public class ProcessorCountParallelLimit : .
+    {
+        public ProcessorCountParallelLimit() { }
+        public int Limit { get; }
+    }
+    public class ReferenceEqualityComparer : .<object>
+    {
+        public ReferenceEqualityComparer() { }
+        public bool Equals(object? x, object? y) { }
+        public int GetHashCode(object obj) { }
+    }
+    public static class TestClassTypeHelper
+    {
+        public static  GetTestClassType(.DataGeneratorMetadata dataGeneratorMetadata) { }
+    }
+    public static class TestNameGenerator
+    {
+        public static string GenerateTestName( testClass, .MethodInfo testMethod) { }
+        public static string GenerateTestName(string className, string methodName) { }
+    }
+    public static class TupleFactory
+    {
+        public static object? CreateTuple([.(..PublicConstructors)]  tupleType, object?[] elements) { }
+        public static bool IsTupleType( type) { }
+        public static bool TryCreateTupleUsingReflection([.(..PublicConstructors)]  tupleType, object?[] elements, out object? result) { }
+    }
+    public static class TupleHelper
+    {
+        [.("Tuple expansion uses reflection as fallback")]
+        public static .<object?[]> ExpandTupleArray(object? value) { }
+        public static bool IsTupleArrayType( type) { }
+        public static bool IsTupleType(. tuple) { }
+        public static bool IsTupleType(? type) { }
+        public static bool IsTupleType(object? obj) { }
+        public static bool ShouldUnwrapForMethodArguments(object? value, int expectedParameterCount) { }
+        public static object?[] UnwrapTuple(.? value) { }
+        public static object?[] UnwrapTuple(object? value) { }
+    }
+}
+namespace .Hooks
+{
+    public class AfterAssemblyHookMethod : .<.AssemblyHookContext>, <.>
+    {
+        public AfterAssemblyHookMethod() { }
+        public override . ExecuteAsync(.AssemblyHookContext context, .CancellationToken cancellationToken) { }
+    }
+    public class AfterClassHookMethod : .<.ClassHookContext>, <.>
+    {
+        public AfterClassHookMethod() { }
+        public override . ExecuteAsync(.ClassHookContext context, .CancellationToken cancellationToken) { }
+    }
+    public class AfterTestDiscoveryHookMethod : .<.TestDiscoveryContext>, <.>
+    {
+        public AfterTestDiscoveryHookMethod() { }
+        public override . ExecuteAsync(.TestDiscoveryContext context, .CancellationToken cancellationToken) { }
+    }
+    public class AfterTestHookMethod : .<.TestContext>, <.>
+    {
+        public AfterTestHookMethod() { }
+        public override . ExecuteAsync(.TestContext context, .CancellationToken cancellationToken) { }
+    }
+    public class AfterTestSessionHookMethod : .<.TestSessionContext>, <.>
+    {
+        public AfterTestSessionHookMethod() { }
+        public override . ExecuteAsync(.TestSessionContext context, .CancellationToken cancellationToken) { }
+    }
+    public class BeforeAssemblyHookMethod : .<.AssemblyHookContext>, <.>
+    {
+        public BeforeAssemblyHookMethod() { }
+        public override . ExecuteAsync(.AssemblyHookContext context, .CancellationToken cancellationToken) { }
+    }
+    public class BeforeClassHookMethod : .<.ClassHookContext>, <.>
+    {
+        public BeforeClassHookMethod() { }
+        public override . ExecuteAsync(.ClassHookContext context, .CancellationToken cancellationToken) { }
+    }
+    public class BeforeTestDiscoveryHookMethod : .<.BeforeTestDiscoveryContext>, <.>
+    {
+        public BeforeTestDiscoveryHookMethod() { }
+        public override . ExecuteAsync(.BeforeTestDiscoveryContext context, .CancellationToken cancellationToken) { }
+    }
+    public class BeforeTestHookMethod : .<.TestContext>, <.>
+    {
+        public BeforeTestHookMethod() { }
+        public override . ExecuteAsync(.TestContext context, .CancellationToken cancellationToken) { }
+    }
+    public class BeforeTestSessionHookMethod : .<.TestSessionContext>, <.>
+    {
+        public BeforeTestSessionHookMethod() { }
+        public override . ExecuteAsync(.TestSessionContext context, .CancellationToken cancellationToken) { }
+    }
+    public abstract class HookMethod : <.>
+    {
+        protected HookMethod() { }
+        public virtual .Assembly? Assembly { get; }
+        public .<> Attributes { get; }
+        [.(..PublicMethods)]
+        public abstract  ClassType { get; }
+        public required . HookExecutor { get; init; }
+        public required .MethodMetadata MethodInfo { get; init; }
+        public string Name { get; }
+        public required int Order { get; init; }
+        public required int RegistrationIndex { get; init; }
+        public ? Timeout { get; }
+        public TAttribute? GetAttribute<TAttribute>()
+            where TAttribute :  { }
+    }
+    public interface IExecutableHook<in T>
+    {
+        .MethodMetadata MethodInfo { get; }
+        string Name { get; }
+        int Order { get; }
+        . ExecuteAsync(T context, .CancellationToken cancellationToken);
+    }
+    public interface IHookMessagePublisher
+    {
+        . Discover(string sessionId, string displayName, . hookMethod);
+        . Push(string sessionId, string displayName, . hookMethod, <.> func);
+    }
+    public class InstanceHookMethod : ., <.>, .<.TestContext>
+    {
+        public InstanceHookMethod() { }
+        public <object, .TestContext, .CancellationToken, .>? Body { get; init; }
+        [.(..PublicMethods)]
+        public override  ClassType { get; }
+        public required  InitClassType { init; }
+        public . ExecuteAsync(.TestContext context, .CancellationToken cancellationToken) { }
+    }
+    public class LastTestInAssemblyAdapter : .<.AssemblyHookContext>
+    {
+        public LastTestInAssemblyAdapter(. lastTestInAssemblyEventReceiver, .TestContext testContext) { }
+        public .MethodMetadata MethodInfo { get; }
+        public string Name { get; }
+        public int Order { get; }
+        public bool Execute(.AssemblyHookContext context, .CancellationToken cancellationToken) { }
+        public . ExecuteAsync(.AssemblyHookContext context, .CancellationToken cancellationToken) { }
+    }
+    [.("Method with DynamicallyAccessedMembersAttribute accessed via reflection")]
+    public class LastTestInClassAdapter : .<.ClassHookContext>
+    {
+        public LastTestInClassAdapter(. lastTestInClassEventReceiver, .TestContext testContext) { }
+        public .MethodMetadata MethodInfo { get; }
+        public string Name { get; }
+        public int Order { get; }
+        public bool Execute(.ClassHookContext context, .CancellationToken cancellationToken) { }
+        public . ExecuteAsync(.ClassHookContext context, .CancellationToken cancellationToken) { }
+    }
+    public abstract class StaticHookMethod : ., <.>
+    {
+        protected StaticHookMethod() { }
+        [.(..PublicMethods)]
+        public override  ClassType { get; }
+        public required string FilePath { get; init; }
+        public required int LineNumber { get; init; }
+    }
+    public abstract class StaticHookMethod<T> : ., <.<T>>, .<T>
+    {
+        protected StaticHookMethod() { }
+        public <T, .CancellationToken, .>? Body { get; init; }
+        public abstract . ExecuteAsync(T context, .CancellationToken cancellationToken);
+    }
+}
+namespace .Interfaces
+{
+    public sealed class CompileTimeResolvedData
+    {
+        public CompileTimeResolvedData() { }
+        public .<object?[]> ClassData { get; init; }
+        public .<object?[]> MethodData { get; init; }
+        public .<string, object?> PropertyData { get; init; }
+        public .<.IDataSourceAttribute> UnresolvedAttributes { get; init; }
+    }
+    public interface IAotCompatibleAsyncDataSource : . { }
+    public interface IAotCompatibleDataSource : . { }
+    public interface IAsyncDataSource
+    {
+        .<<object?[]>> GenerateDataFactoriesAsync(.DataSourceContext context, .CancellationToken cancellationToken = default);
+    }
+    public interface IAsyncInitializer
+    {
+        . InitializeAsync();
+    }
+    public interface IClassConstructor
+    {
+        .<object> Create([.(..PublicConstructors)]  type, .ClassConstructorMetadata classConstructorMetadata);
+    }
+    public interface ICompileTimeDataResolver
+    {
+        bool CanResolveAtCompileTime(.IDataSourceAttribute dataAttribute);
+        .<.<object?[]>> ResolveClassDataAsync(.ClassMetadata classMetadata);
+        .<.<object?[]>> ResolveMethodDataAsync(.MethodMetadata methodMetadata);
+        .<.<string, object?>> ResolvePropertyDataAsync(.ClassMetadata classMetadata);
+    }
+    public interface IConfiguration
+    {
+        string? Get(string key);
+    }
+    public interface IContext
+    {
+        .TextWriter ErrorOutputWriter { get; }
+        .TextWriter OutputWriter { get; }
+        . GetDefaultLogger();
+    }
+    public interface IDataSource
+    {
+        .<<object?[]>> GenerateDataFactories(.DataSourceContext context);
+    }
+    public interface IEventReceiver
+    {
+        int Order { get; }
+    }
+    public interface IExecutionOrder
+    {
+        int Order { get; }
+        int Priority { get; }
+    }
+    public interface IFirstTestInAssemblyEventReceiver : .
+    {
+        . OnFirstTestInAssembly(.AssemblyHookContext context, .TestContext testContext);
+    }
+    public interface IFirstTestInClassEventReceiver : .
+    {
+        . OnFirstTestInClass(.ClassHookContext context, .TestContext testContext);
+    }
+    public interface IFirstTestInTestSessionEventReceiver : .
+    {
+        . OnFirstTestInTestSession(.TestSessionContext current, .TestContext testContext);
+    }
+    public interface IGenericTypeResolver
+    {
+        [] ResolveGenericClassArguments([.(..PublicConstructors)]  genericTypeDefinition, object?[] constructorArguments);
+        [] ResolveGenericMethodArguments(.MethodInfo genericMethodDefinition, object?[] runtimeArguments);
+    }
+    public interface IHasLoggers
+    {
+        .<.> Loggers { get; }
+    }
+    public interface IHookExecutor
+    {
+        . ExecuteAfterAssemblyHook(.MethodMetadata hookMethodInfo, .AssemblyHookContext context, <.> action);
+        . ExecuteAfterClassHook(.MethodMetadata hookMethodInfo, .ClassHookContext context, <.> action);
+        . ExecuteAfterTestDiscoveryHook(.MethodMetadata hookMethodInfo, .TestDiscoveryContext context, <.> action);
+        . ExecuteAfterTestHook(.MethodMetadata hookMethodInfo, .TestContext context, <.> action);
+        . ExecuteAfterTestSessionHook(.MethodMetadata hookMethodInfo, .TestSessionContext context, <.> action);
+        . ExecuteBeforeAssemblyHook(.MethodMetadata hookMethodInfo, .AssemblyHookContext context, <.> action);
+        . ExecuteBeforeClassHook(.MethodMetadata hookMethodInfo, .ClassHookContext context, <.> action);
+        . ExecuteBeforeTestDiscoveryHook(.MethodMetadata hookMethodInfo, .BeforeTestDiscoveryContext context, <.> action);
+        . ExecuteBeforeTestHook(.MethodMetadata hookMethodInfo, .TestContext context, <.> action);
+        . ExecuteBeforeTestSessionHook(.MethodMetadata hookMethodInfo, .TestSessionContext context, <.> action);
+    }
+    public interface IHookRegisteredEventReceiver : .
+    {
+        . OnHookRegistered(.HookRegisteredContext context);
+    }
+    public interface IInfersType<T> { }
+    public interface ILastTestInAssemblyEventReceiver : .
+    {
+        . OnLastTestInAssembly(.AssemblyHookContext context, .TestContext testContext);
+    }
+    public interface ILastTestInClassEventReceiver : .
+    {
+        . OnLastTestInClass(.ClassHookContext context, .TestContext testContext);
+    }
+    public interface ILastTestInTestSessionEventReceiver : .
+    {
+        . OnLastTestInTestSession(.TestSessionContext current, .TestContext testContext);
+    }
+    public interface IParallelConstraint { }
+    public interface IParallelLimit
+    {
+        int Limit { get; }
+    }
+    public interface ISourceGeneratedTestRegistry
+    {
+        <object>? GetClassFactory(string testId);
+        <object, object?[], .<object?>>? GetMethodInvoker(string testId);
+        <object?[], object>? GetParameterizedClassFactory(string testId);
+        .<string> GetRegisteredTestIds();
+        void RegisterClassFactory(string testId, <object> factory);
+        void RegisterClassFactory(string testId, <object?[], object> factory);
+        void RegisterMethodInvoker(string testId, <object, object?[], .<object?>> invoker);
+    }
+    public interface ITestDiscoveryEventReceiver : .
+    {
+        . OnTestDiscovered(.DiscoveredTestContext context);
+    }
+    public interface ITestEndEventReceiver : .
+    {
+        . OnTestEnd(.TestContext context);
+    }
+    public interface ITestExecutor
+    {
+        . ExecuteTest(.TestContext context, <.> action);
+    }
+    public interface ITestFinder
+    {
+        .<.TestContext> GetTests( classType);
+        .TestContext[] GetTestsByNameAndParameters(string testName, .<> methodParameterTypes,  classType, .<> classParameterTypes, .<object?> classArguments);
+    }
+    public interface ITestNameFormatter
+    {
+        string BuildTestId(string template, int testIndex, int repeatIndex = 0, int classDataIndex = 0, int methodDataIndex = 0);
+        string FormatArgumentValue(object? value);
+        string FormatTestName(string template, object?[]? classArgs = null, object?[]? methodArgs = null, .<string, object?>? propertyValues = null);
+    }
+    public interface ITestRegisteredEventReceiver : .
+    {
+        [.("Type comes from runtime objects that cannot be annotated")]
+        . OnTestRegistered(.TestRegisteredContext context);
+    }
+    public interface ITestRegistry
+    {
+        [.("Adding dynamic tests requires runtime compilation and reflection which are not su" +
+            "pported in native AOT scenarios.")]
+        [.("Dynamic test metadata creation uses reflection")]
+        . AddDynamicTest<[.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicFields | ..NonPublicFields | ..PublicProperties)]  T>(.TestContext context, .DynamicTest<T> dynamicTest)
+            where T :  class;
+    }
+    public interface ITestRetryEventReceiver : .
+    {
+        . OnTestRetry(.TestContext context, int retryAttempt);
+    }
+    public interface ITestSkippedEventReceiver : .
+    {
+        . OnTestSkipped(.TestContext context);
+    }
+    public interface ITestStartEventReceiver : .
+    {
+        . OnTestStart(.TestContext context);
+    }
+    public interface ITypedTestMetadata
+    {
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]
+         TestClassType { get; }
+    }
+}
+namespace .
+{
+    public interface IPropertySource
+    {
+        bool ShouldInitialize { get; }
+         Type { get; }
+        .<..PropertyInjectionMetadata> GetPropertyMetadata();
+    }
+    public interface ITestSource
+    {
+        .<.TestMetadata> GetTestsAsync(string testSessionId, .CancellationToken cancellationToken = default);
+    }
+    public sealed class PropertyInjectionMetadata
+    {
+        public PropertyInjectionMetadata() { }
+        [.(..PublicProperties)]
+        public required  ContainingType { get; init; }
+        public required <.IDataSourceAttribute> CreateDataSource { get; init; }
+        public required string PropertyName { get; init; }
+        [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..NonPublicConstructors | ..PublicMethods | ..NonPublicMethods | ..PublicProperties)]
+        public required  PropertyType { get; init; }
+        public required <object, object?> SetProperty { get; init; }
+    }
+}
+namespace .Logging
+{
+    public class DefaultLogger : .
+    {
+        public DefaultLogger(.Context context) { }
+        public override void Log<TState>(. logLevel, TState state, ? exception, <TState, ?, string> formatter) { }
+        public override . LogAsync<TState>(. logLevel, TState state, ? exception, <TState, ?, string> formatter) { }
+        public void PushProperties(.<string, .<object>> dictionary) { }
+        public void PushProperty(string name, object? value) { }
+    }
+    public interface ILogger
+    {
+        bool IsEnabled(. logLevel);
+        void Log<TState>(. logLevel, TState state, ? exception, <TState, ?, string> formatter);
+        . LogAsync<TState>(. logLevel, TState state, ? exception, <TState, ?, string> formatter);
+    }
+    public interface ILogger<out TCategoryName> : . { }
+    public enum LogLevel
+    {
+        Trace = 0,
+        Debug = 1,
+        Information = 2,
+        Warning = 3,
+        Error = 4,
+        Critical = 5,
+        None = 6,
+    }
+    public static class LoggingExtensions
+    {
+        public static void LogCritical(this . logger, string message) { }
+        public static . LogCriticalAsync(this . logger, string message) { }
+        public static void LogDebug(this . logger, string message) { }
+        public static . LogDebugAsync(this . logger, string message) { }
+        public static void LogError(this . logger,  ex) { }
+        public static void LogError(this . logger, string message) { }
+        public static void LogError(this . logger, string message,  ex) { }
+        public static . LogErrorAsync(this . logger,  ex) { }
+        public static . LogErrorAsync(this . logger, string message) { }
+        public static . LogErrorAsync(this . logger, string message,  ex) { }
+        public static void LogInformation(this . logger, string message) { }
+        public static . LogInformationAsync(this . logger, string message) { }
+        public static void LogTrace(this . logger, string message) { }
+        public static . LogTraceAsync(this . logger, string message) { }
+        public static void LogWarning(this . logger, string message) { }
+        public static . LogWarningAsync(this . logger, string message) { }
+    }
+    public abstract class TUnitLogger : .
+    {
+        protected TUnitLogger() { }
+        public virtual bool IsEnabled(. logLevel) { }
+        public abstract void Log<TState>(. logLevel, TState state, ? exception, <TState, ?, string> formatter);
+        public abstract . LogAsync<TState>(. logLevel, TState state, ? exception, <TState, ?, string> formatter);
+    }
+}
+namespace .Models
+{
+    public enum ExecutionContextType
+    {
+        Parallel = 0,
+        NotInParallel = 1,
+        KeyedNotInParallel = 2,
+        ParallelGroup = 3,
+    }
+    public class TestExecutionContext : <.>
+    {
+        public TestExecutionContext() { }
+        public required . ContextType { get; init; }
+        public string? GroupKey { get; init; }
+        public int? Order { get; init; }
+    }
+    public class TestExecutionData
+    {
+        public TestExecutionData() { }
+        public <.DataGeneratorMetadata, .CancellationToken, .<.<object?[]?>>>? AsyncDataExecutor { get; set; }
+        public <.DataGeneratorMetadata, .CancellationToken, .<.<<.<object?[]?>>>>>? AsyncDataSourceResolver { get; set; }
+        public <.<.<object?[]>>>? AsyncMethodDataResolver { get; set; }
+        public ? ClassFactory { get; set; }
+        public bool HasAsyncDataSource { get; }
+        public bool HasMethodDataResolver { get; }
+        public bool HasStronglyTypedDelegates { get; }
+        public <.<object?[]>>? MethodDataResolver { get; set; }
+        public ? MethodInvoker { get; set; }
+    }
+}
+namespace .Services
+{
+    [.("Generic type resolution requires runtime type generation")]
+    [.("Generic type resolution may access types not preserved by trimming")]
+    public class GenericTypeResolver : .
+    {
+        public GenericTypeResolver() { }
+        public [] ResolveGenericClassArguments([.(..PublicConstructors)]  genericTypeDefinition, object?[] constructorArguments) { }
+        public [] ResolveGenericMethodArguments(.MethodInfo genericMethodDefinition, object?[] runtimeArguments) { }
+    }
+    public interface IContextProvider
+    {
+        .BeforeTestDiscoveryContext BeforeTestDiscoveryContext { get; }
+        .TestDiscoveryContext TestDiscoveryContext { get; }
+        .TestSessionContext TestSessionContext { get; }
+        .TestContext CreateTestContext(string testName, [.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  classType, .TestBuilderContext testBuilderContext, .CancellationToken cancellationToken);
+        .AssemblyHookContext GetOrCreateAssemblyContext(.Assembly assembly);
+        .ClassHookContext GetOrCreateClassContext([.(..None | ..PublicParameterlessConstructor | ..PublicConstructors | ..PublicMethods | ..PublicProperties)]  classType);
+    }
+    public static class ModeDetector
+    {
+        public static bool IsSourceGenerationAvailable { get; }
+    }
+    public class NoOpGenericTypeResolver : .
+    {
+        public NoOpGenericTypeResolver() { }
+        public [] ResolveGenericClassArguments([.(..PublicConstructors)]  genericTypeDefinition, object?[] constructorArguments) { }
+        public [] ResolveGenericMethodArguments(.MethodInfo genericMethodDefinition, object?[] runtimeArguments) { }
+    }
+    public static class ServiceProviderExtensions
+    {
+        public static object GetRequiredService(this  serviceProvider,  serviceType) { }
+        public static T GetRequiredService<T>(this  serviceProvider)
+            where T :  class { }
+        public static T? GetService<T>(this  serviceProvider)
+            where T :  class { }
+    }
+    public class TestExecutionRegistry : .
+    {
+        public TestExecutionRegistry() { }
+        public static . Instance { get; }
+        public void Clear() { }
+        public <.DataGeneratorMetadata, .CancellationToken, .<.<object?[]?>>>? GetAsyncDataExecutor(string testId) { }
+        public <.DataGeneratorMetadata, .CancellationToken, .<.<<.<object?[]?>>>>>? GetAsyncDataSourceResolver(string testId) { }
+        public <.<.<object?[]>>>? GetAsyncMethodDataResolver(string testId) { }
+        public <object>? GetClassFactory(string testId) { }
+        public <.<object?[]>>? GetMethodDataResolver(string testId) { }
+        public <object, object?[], .<object?>>? GetMethodInvoker(string testId) { }
+        public . GetOrCreateTestData(string testId) { }
+        public <object?[], object>? GetParameterizedClassFactory(string testId) { }
+        public .<string> GetRegisteredTestIds() { }
+        public T? GetStronglyTypedClassFactory<T>(string testId)
+            where T :  { }
+        public T? GetStronglyTypedMethodInvoker<T>(string testId)
+            where T :  { }
+        public .? GetTestData(string testId) { }
+        public bool HasAsyncDataSourceResolver(string testId) { }
+        public bool HasMethodDataResolver(string testId) { }
+        public bool HasStronglyTypedFactory(string testId) { }
+        public void RegisterAsyncDataExecutor(string testId, <.DataGeneratorMetadata, .CancellationToken, .<.<object?[]?>>> executor) { }
+        public void RegisterAsyncDataSourceResolver(string testId, <.DataGeneratorMetadata, .CancellationToken, .<.<<.<object?[]?>>>>> resolver) { }
+        public void RegisterAsyncMethodDataResolver(string testId, <.<.<object?[]>>> resolver) { }
+        public void RegisterClassFactory(string testId, <object> factory) { }
+        public void RegisterClassFactory(string testId, <object?[], object> factory) { }
+        public void RegisterMethodDataResolver(string testId, <.<object?[]>> resolver) { }
+        public void RegisterMethodInvoker(string testId, <object, object?[], .<object?>> invoker) { }
+        public void RegisterStronglyTypedClassFactory<T>(string testId,  factory)
+            where T :  class { }
+        public void RegisterStronglyTypedClassFactory<T>(string testId, <T> factory)
+            where T :  class { }
+        public void RegisterStronglyTypedMethodInvoker<T>(string testId,  invoker)
+            where T :  class { }
+        public void RegisterTest(string testId, . data) { }
+    }
+    public class TestNameFormatter : .
+    {
+        public TestNameFormatter() { }
+        public string BuildTestId(string template, int testIndex, int repeatIndex = 0, int classDataIndex = 0, int methodDataIndex = 0) { }
+        public string FormatArgumentValue(object? value) { }
+        public string FormatTestName(string template, object?[]? classArgs = null, object?[]? methodArgs = null, .<string, object?>? propertyValues = null) { }
+    }
+    public class TestServiceProvider : 
+    {
+        public TestServiceProvider() { }
+        public . AddSingleton( serviceType, object service) { }
+        public . AddSingleton<T>(T service)
+            where T :  class { }
+        public . AddTransient( serviceType, <object> factory) { }
+        public . AddTransient<T>(<T> factory)
+            where T :  class { }
+        public object? GetService( serviceType) { }
+    }
+}
+namespace .StaticProperties
+{
+    public sealed class StaticPropertyMetadata
+    {
+        public StaticPropertyMetadata() { }
+        public required  DeclaringType { get; init; }
+        public required <.<object?>> InitializerAsync { get; init; }
+        public required string PropertyName { get; init; }
+        public required  PropertyType { get; init; }
+    }
+    public static class StaticPropertyRegistry
+    {
+        public static .<.> GetRegisteredProperties() { }
+        public static void Register(. metadata) { }
+        public static bool TryGetInitializedValue( declaringType, string propertyName, out object? value) { }
+    }
+}
\ No newline at end of file
diff --git a/TUnit.PublicAPI/Tests.Playwright_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Playwright_Library_Has_No_API_Changes.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..2af9d26627
--- /dev/null
+++ b/TUnit.PublicAPI/Tests.Playwright_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -0,0 +1,94 @@
+[assembly: .(".NETCoreApp,Version=v10.0", FrameworkDisplayName=".NET 10.0")]
+namespace 
+{
+    public static class AotMethodInvokers
+    {
+        public static string GetMethodKey(string typeName, string methodName, int parameterCount = 0) { }
+        public static .<object?> InvokeMethodAsync(string methodKey, object? instance, params object?[]? parameters) { }
+    }
+}
+namespace 
+{
+    public class BrowserTest : .PlaywrightTest
+    {
+        public BrowserTest() { }
+        public BrowserTest(.BrowserTypeLaunchOptions options) { }
+        public .IBrowser Browser { get; }
+        [.Before(., "", 0)]
+        public . BrowserSetup() { }
+        [.After(., "", 0)]
+        public . BrowserTearDown(.TestContext testContext) { }
+        public .<.IBrowserContext> NewContext(.BrowserNewContextOptions options) { }
+    }
+    public class ContextTest : .BrowserTest
+    {
+        public ContextTest() { }
+        public .IBrowserContext Context { get; }
+        public virtual .BrowserNewContextOptions ContextOptions(.TestContext testContext) { }
+        [.Before(., "", 0)]
+        public . ContextSetup(.TestContext testContext) { }
+    }
+    public sealed class DefaultPlaywrightParallelLimiter : .
+    {
+        public DefaultPlaywrightParallelLimiter() { }
+        public int Limit { get; }
+    }
+    public interface IWorkerService
+    {
+        . DisposeAsync();
+        . ResetAsync();
+    }
+    public class PageTest : .ContextTest
+    {
+        public PageTest() { }
+        public .IPage Page { get; }
+        [.Before(., "", 0)]
+        public . PageSetup() { }
+    }
+    public class PlaywrightSkipAttribute : .SkipAttribute
+    {
+        public PlaywrightSkipAttribute(params .[] combinations) { }
+        public .TestContext? TestContext { get; set; }
+        public override .<bool> ShouldSkip(.TestRegisteredContext context) { }
+        []
+        public enum Targets : short
+        {
+            Windows = 1,
+            Linux = 2,
+            OSX = 4,
+            Chromium = 8,
+            Firefox = 16,
+            Webkit = 32,
+        }
+    }
+    public class PlaywrightTest : .WorkerAwareTest
+    {
+        public PlaywrightTest() { }
+        public virtual string BrowserName { get; }
+        public .IBrowserType BrowserType { get; }
+        public static .IPlaywright Playwright { get; }
+        public .IAPIResponseAssertions Expect(.IAPIResponse response) { }
+        public .ILocatorAssertions Expect(.ILocator locator) { }
+        public .IPageAssertions Expect(.IPage page) { }
+        [.After(., "", 0)]
+        public static void PlaywrightCleanup() { }
+        [.Before(., "", 0)]
+        public static . PlaywrightSetup() { }
+        public static void SetDefaultExpectTimeout(float timeout) { }
+    }
+    public class WorkerAwareTest : ., .
+    {
+        public WorkerAwareTest() { }
+        public virtual bool UseDefaultParallelLimiter { get; }
+        public int WorkerIndex { get; }
+        [.("Type comes from runtime objects that cannot be annotated")]
+        public . OnTestRegistered(.TestRegisteredContext context) { }
+        public .<T> RegisterService<T>(string name, <.<T>> factory)
+            where T :  class, .IWorkerService { }
+        protected bool TestOk(.TestContext testContext) { }
+        [.Before(., "", 0)]
+        public void WorkerSetup() { }
+        [.After(., "", 0)]
+        public . WorkerTeardown(.TestContext testContext) { }
+    }
+}
\ No newline at end of file
diff --git a/TUnit.Templates.Tests/TUnit.Templates.Tests.csproj b/TUnit.Templates.Tests/TUnit.Templates.Tests.csproj
index d5327596c6..bfa9211dda 100644
--- a/TUnit.Templates.Tests/TUnit.Templates.Tests.csproj
+++ b/TUnit.Templates.Tests/TUnit.Templates.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="..\TestProject.props" />
   
   <PropertyGroup>
-    <TargetFrameworks>net9.0</TargetFrameworks>
+    <TargetFrameworks>net9.0;net10.0</TargetFrameworks>
   </PropertyGroup>
   
   <ItemGroup>
diff --git a/TUnit.TestProject.Library/TUnit.TestProject.Library.csproj b/TUnit.TestProject.Library/TUnit.TestProject.Library.csproj
index db4105a7d9..b7d6a48bea 100644
--- a/TUnit.TestProject.Library/TUnit.TestProject.Library.csproj
+++ b/TUnit.TestProject.Library/TUnit.TestProject.Library.csproj
@@ -7,7 +7,7 @@
     <Import Project="..\TestLibrary.props" />
 
     <PropertyGroup>
-        <TargetFrameworks>net6.0;net8.0;net9.0;net472;netstandard2.0</TargetFrameworks>
+        <TargetFrameworks>net6.0;net8.0;net9.0;net10.0;net472;netstandard2.0</TargetFrameworks>
     </PropertyGroup>
 
     <Import Project="..\TestLibrary.targets" />
diff --git a/TestProject.props b/TestProject.props
index 238bbc0f44..afb048f822 100644
--- a/TestProject.props
+++ b/TestProject.props
@@ -9,7 +9,7 @@
         Condition="'$(MSBuildProjectExtension)' == '.fsproj'" />
 
     <PropertyGroup>
-        <TargetFrameworks>net472;net8.0;net9.0</TargetFrameworks>
+        <TargetFrameworks>net472;net8.0;net9.0;net10.0</TargetFrameworks>
 
         <OutputType>Exe</OutputType>
 
diff --git a/global.json b/global.json
index 0a1a4c512f..dfba20f63f 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "9.0.305",
+    "version": "10.0.100-rc.1.25451.107",
     "rollForward": "latestFeature"
   }
 }
diff --git a/tools/speed-comparison/TestVersions/TestVersions.csproj b/tools/speed-comparison/TestVersions/TestVersions.csproj
index 3477df059b..5c0a78df5a 100644
--- a/tools/speed-comparison/TestVersions/TestVersions.csproj
+++ b/tools/speed-comparison/TestVersions/TestVersions.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
diff --git a/tools/speed-comparison/Tests.Benchmark/Tests.Benchmark.csproj b/tools/speed-comparison/Tests.Benchmark/Tests.Benchmark.csproj
index 67edfda905..71c36188ac 100644
--- a/tools/speed-comparison/Tests.Benchmark/Tests.Benchmark.csproj
+++ b/tools/speed-comparison/Tests.Benchmark/Tests.Benchmark.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+        <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>
diff --git a/tools/speed-comparison/UnifiedTests/UnifiedTests.csproj b/tools/speed-comparison/UnifiedTests/UnifiedTests.csproj
index 404a4a3bee..6e630f9382 100644
--- a/tools/speed-comparison/UnifiedTests/UnifiedTests.csproj
+++ b/tools/speed-comparison/UnifiedTests/UnifiedTests.csproj
@@ -5,7 +5,7 @@
     </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
diff --git a/tools/tunit-nuget-tester/TUnit.NugetTester/TUnit.NugetTester/TUnit.NugetTester.csproj b/tools/tunit-nuget-tester/TUnit.NugetTester/TUnit.NugetTester/TUnit.NugetTester.csproj
index 42163c3879..6f6e2b08d8 100644
--- a/tools/tunit-nuget-tester/TUnit.NugetTester/TUnit.NugetTester/TUnit.NugetTester.csproj
+++ b/tools/tunit-nuget-tester/TUnit.NugetTester/TUnit.NugetTester/TUnit.NugetTester.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net6.0;net8.0;net9.0;net462;net472;net48;net481</TargetFrameworks>
+        <TargetFrameworks>net6.0;net8.0;net9.0;net10.0;net462;net472;net48;net481</TargetFrameworks>
         <LangVersion>latest</LangVersion>
         <IsLibraryTestProject>true</IsLibraryTestProject>
         <ImplicitUsings>enable</ImplicitUsings>