diff --git a/TUnit.Assertions.Tests/Old/DictionaryAssertionTests.cs b/TUnit.Assertions.Tests/Old/DictionaryAssertionTests.cs
index 5a9ac0c981..499cf6447f 100644
--- a/TUnit.Assertions.Tests/Old/DictionaryAssertionTests.cs
+++ b/TUnit.Assertions.Tests/Old/DictionaryAssertionTests.cs
@@ -66,6 +66,18 @@ await TUnitAssert.That(ImmutableDictionary<string, int>.Empty.Add("Hello", 1))
         );
     }
 
+    // Picks up collection methods via inheritance
+    [Test]
+    public async Task HasSingleItem()
+    {
+        var dictionary = new Dictionary<string, byte[]>
+        {
+            ["Blah"] = [1]
+        };
+
+        await TUnitAssert.That(dictionary).HasSingleItem();
+    }
+
     public class ReadDictionary : IReadOnlyDictionary<string, string>
     {
         public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
diff --git a/TUnit.Assertions/Conditions/CollectionAssertions.cs b/TUnit.Assertions/Conditions/CollectionAssertions.cs
index 9fa3151d43..e9175e8719 100644
--- a/TUnit.Assertions/Conditions/CollectionAssertions.cs
+++ b/TUnit.Assertions/Conditions/CollectionAssertions.cs
@@ -11,15 +11,16 @@ namespace TUnit.Assertions.Conditions;
 /// Asserts that a collection/enumerable is empty.
 /// </summary>
 [AssertionExtension("IsEmpty")]
-public class CollectionIsEmptyAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionIsEmptyAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     public CollectionIsEmptyAssertion(
-        AssertionContext<IEnumerable<TItem>> context)
+        AssertionContext<TCollection> context)
         : base(context)
     {
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -82,15 +83,16 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Asserts that a collection/enumerable is NOT empty.
 /// </summary>
 [AssertionExtension("IsNotEmpty")]
-public class CollectionIsNotEmptyAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionIsNotEmptyAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     public CollectionIsNotEmptyAssertion(
-        AssertionContext<IEnumerable<TItem>> context)
+        AssertionContext<TCollection> context)
         : base(context)
     {
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -129,13 +131,14 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("Contains")]
-public class CollectionContainsAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionContainsAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly TItem _expected;
     private readonly IEqualityComparer<TItem>? _comparer;
 
     public CollectionContainsAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         TItem expected,
         IEqualityComparer<TItem>? comparer = null)
         : base(context)
@@ -144,7 +147,7 @@ public CollectionContainsAssertion(
         _comparer = comparer;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -180,13 +183,14 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("DoesNotContain")]
-public class CollectionDoesNotContainAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionDoesNotContainAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly TItem _expected;
     private readonly IEqualityComparer<TItem>? _comparer;
 
     public CollectionDoesNotContainAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         TItem expected,
         IEqualityComparer<TItem>? comparer = null)
         : base(context)
@@ -195,7 +199,7 @@ public CollectionDoesNotContainAssertion(
         _comparer = comparer;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -231,13 +235,14 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("DoesNotContain")]
-public class CollectionDoesNotContainPredicateAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionDoesNotContainPredicateAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, bool> _predicate;
     private readonly string _predicateDescription;
 
     public CollectionDoesNotContainPredicateAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, bool> predicate,
         string predicateDescription)
         : base(context)
@@ -246,7 +251,7 @@ public CollectionDoesNotContainPredicateAssertion(
         _predicateDescription = predicateDescription;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -280,19 +285,20 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("HasCount")]
-public class CollectionCountAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionCountAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly int _expectedCount;
 
     public CollectionCountAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         int expectedCount)
         : base(context)
     {
         _expectedCount = expectedCount;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -345,11 +351,12 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// <summary>
 /// Helper for All().Satisfy() pattern - allows custom assertions on all collection items.
 /// </summary>
-public class CollectionAllSatisfyHelper<TItem>
+public class CollectionAllSatisfyHelper<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
-    private readonly AssertionContext<IEnumerable<TItem>> _context;
+    private readonly AssertionContext<TCollection> _context;
 
-    public CollectionAllSatisfyHelper(AssertionContext<IEnumerable<TItem>> context)
+    public CollectionAllSatisfyHelper(AssertionContext<TCollection> context)
     {
         _context = context;
     }
@@ -358,38 +365,39 @@ public CollectionAllSatisfyHelper(AssertionContext<IEnumerable<TItem>> context)
     /// Asserts that all items satisfy the given assertion.
     /// Example: .All().Satisfy(item => item.IsNotNull())
     /// </summary>
-    public CollectionAllSatisfyAssertion<TItem> Satisfy(
+    public CollectionAllSatisfyAssertion<TCollection, TItem> Satisfy(
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion,
         [CallerArgumentExpression(nameof(assertion))] string? expression = null)
     {
         _context.ExpressionBuilder.Append($".Satisfy({expression})");
-        return new CollectionAllSatisfyAssertion<TItem>(_context, assertion, expression ?? "assertion");
+        return new CollectionAllSatisfyAssertion<TCollection, TItem>(_context, assertion, expression ?? "assertion");
     }
 
     /// <summary>
     /// Asserts that all items, when mapped, satisfy the given assertion.
     /// Example: .All().Satisfy(model => model.Value, assert => assert.IsNotNull())
     /// </summary>
-    public CollectionAllSatisfyMappedAssertion<TItem, TMapped> Satisfy<TMapped>(
+    public CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped> Satisfy<TMapped>(
         Func<TItem, TMapped> mapper,
         Func<IAssertionSource<TMapped>, Assertion<TMapped>?> assertion,
         [CallerArgumentExpression(nameof(mapper))] string? mapperExpression = null,
         [CallerArgumentExpression(nameof(assertion))] string? assertionExpression = null)
     {
         _context.ExpressionBuilder.Append($".Satisfy({mapperExpression}, {assertionExpression})");
-        return new CollectionAllSatisfyMappedAssertion<TItem, TMapped>(
+        return new CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped>(
             _context, mapper, assertion, mapperExpression ?? "mapper", assertionExpression ?? "assertion");
     }
 }
 
 [AssertionExtension("All")]
-public class CollectionAllAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionAllAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, bool> _predicate;
     private readonly string _predicateDescription;
 
     public CollectionAllAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, bool> predicate,
         string predicateDescription)
         : base(context)
@@ -398,7 +406,7 @@ public CollectionAllAssertion(
         _predicateDescription = predicateDescription;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -435,13 +443,14 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("Any")]
-public class CollectionAnyAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionAnyAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, bool> _predicate;
     private readonly string _predicateDescription;
 
     public CollectionAnyAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, bool> predicate,
         string predicateDescription)
         : base(context)
@@ -450,7 +459,7 @@ public CollectionAnyAssertion(
         _predicateDescription = predicateDescription;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -485,17 +494,18 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("HasSingleItem")]
-public class HasSingleItemAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class HasSingleItemAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private TItem? _singleItem;
 
     public HasSingleItemAssertion(
-        AssertionContext<IEnumerable<TItem>> context)
+        AssertionContext<TCollection> context)
         : base(context)
     {
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -558,20 +568,21 @@ private async Task<TItem> ExecuteAndReturnItemAsync()
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
 [AssertionExtension("Contains")]
-public class CollectionContainsPredicateAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionContainsPredicateAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, bool> _predicate;
     private TItem? _foundItem;
 
     public CollectionContainsPredicateAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, bool> predicate)
         : base(context)
     {
         _predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -621,13 +632,14 @@ private async Task<TItem> ExecuteAndReturnItemAsync()
 /// Asserts that all items in the collection satisfy a custom assertion.
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
-public class CollectionAllSatisfyAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionAllSatisfyAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<IAssertionSource<TItem>, Assertion<TItem>?> _assertion;
     private readonly string _assertionDescription;
 
     public CollectionAllSatisfyAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion,
         string assertionDescription)
         : base(context)
@@ -636,7 +648,7 @@ public CollectionAllSatisfyAssertion(
         _assertionDescription = assertionDescription;
     }
 
-    protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -680,7 +692,8 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<IEn
 /// Asserts that all items in the collection, when mapped, satisfy a custom assertion.
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// </summary>
-public class CollectionAllSatisfyMappedAssertion<TItem, TMapped> : Sources.CollectionAssertionBase<TItem>
+public class CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, TMapped> _mapper;
     private readonly Func<IAssertionSource<TMapped>, Assertion<TMapped>?> _assertion;
@@ -688,7 +701,7 @@ public class CollectionAllSatisfyMappedAssertion<TItem, TMapped> : Sources.Colle
     private readonly string _assertionDescription;
 
     public CollectionAllSatisfyMappedAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, TMapped> mapper,
         Func<IAssertionSource<TMapped>, Assertion<TMapped>?> assertion,
         string mapperDescription,
@@ -701,7 +714,7 @@ public CollectionAllSatisfyMappedAssertion(
         _assertionDescription = assertionDescription;
     }
 
-    protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -748,15 +761,16 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<IEn
 /// Uses runtime comparison via Comparer&lt;TItem&gt;.Default to allow instance method usage without constraints.
 /// </summary>
 [AssertionExtension("IsInOrder")]
-public class CollectionIsInOrderAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionIsInOrderAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     public CollectionIsInOrderAssertion(
-        AssertionContext<IEnumerable<TItem>> context)
+        AssertionContext<TCollection> context)
         : base(context)
     {
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -803,15 +817,16 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Uses runtime comparison via Comparer&lt;TItem&gt;.Default to allow instance method usage without constraints.
 /// </summary>
 [AssertionExtension("IsInDescendingOrder")]
-public class CollectionIsInDescendingOrderAssertion<TItem> : Sources.CollectionAssertionBase<TItem>
+public class CollectionIsInDescendingOrderAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     public CollectionIsInDescendingOrderAssertion(
-        AssertionContext<IEnumerable<TItem>> context)
+        AssertionContext<TCollection> context)
         : base(context)
     {
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -857,13 +872,14 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// Available as an instance method on CollectionAssertionBase for proper type inference.
 /// </summary>
-public class CollectionIsOrderedByAssertion<TItem, TKey> : Sources.CollectionAssertionBase<TItem>
+public class CollectionIsOrderedByAssertion<TCollection, TItem, TKey> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, TKey> _keySelector;
     private readonly IComparer<TKey>? _comparer;
 
     public CollectionIsOrderedByAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, TKey> keySelector,
         IComparer<TKey>? comparer = null)
         : base(context)
@@ -872,7 +888,7 @@ public CollectionIsOrderedByAssertion(
         _comparer = comparer;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
@@ -918,13 +934,14 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerab
 /// Inherits from CollectionAssertionBase to enable chaining of collection methods.
 /// Available as an instance method on CollectionAssertionBase for proper type inference.
 /// </summary>
-public class CollectionIsOrderedByDescendingAssertion<TItem, TKey> : Sources.CollectionAssertionBase<TItem>
+public class CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> : Sources.CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly Func<TItem, TKey> _keySelector;
     private readonly IComparer<TKey>? _comparer;
 
     public CollectionIsOrderedByDescendingAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         Func<TItem, TKey> keySelector,
         IComparer<TKey>? comparer = null)
         : base(context)
@@ -933,7 +950,7 @@ public CollectionIsOrderedByDescendingAssertion(
         _comparer = comparer;
     }
 
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
diff --git a/TUnit.Assertions/Conditions/CollectionComparerBasedAssertion.cs b/TUnit.Assertions/Conditions/CollectionComparerBasedAssertion.cs
index 34d98f1167..5a2f78fec1 100644
--- a/TUnit.Assertions/Conditions/CollectionComparerBasedAssertion.cs
+++ b/TUnit.Assertions/Conditions/CollectionComparerBasedAssertion.cs
@@ -8,12 +8,14 @@ namespace TUnit.Assertions.Conditions;
 /// Base class for collection assertions that support custom equality comparers.
 /// Inherits from CollectionAssertionBase to ensure And/Or continuations preserve collection type awareness.
 /// </summary>
+/// <typeparam name="TCollection">The concrete collection type</typeparam>
 /// <typeparam name="TItem">The type of items being compared</typeparam>
-public abstract class CollectionComparerBasedAssertion<TItem> : CollectionAssertionBase<TItem>
+public abstract class CollectionComparerBasedAssertion<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private IEqualityComparer<TItem>? _comparer;
 
-    protected CollectionComparerBasedAssertion(AssertionContext<IEnumerable<TItem>> context)
+    protected CollectionComparerBasedAssertion(AssertionContext<TCollection> context)
         : base(context)
     {
     }
diff --git a/TUnit.Assertions/Conditions/CollectionCountValueAssertion.cs b/TUnit.Assertions/Conditions/CollectionCountValueAssertion.cs
index 3fc3498cb1..2b1c5a9670 100644
--- a/TUnit.Assertions/Conditions/CollectionCountValueAssertion.cs
+++ b/TUnit.Assertions/Conditions/CollectionCountValueAssertion.cs
@@ -7,17 +7,18 @@ namespace TUnit.Assertions.Conditions;
 /// Assertion that evaluates the count of a collection and provides numeric assertions on that count.
 /// Implements IAssertionSource&lt;int&gt; to enable all numeric assertion methods.
 /// </summary>
-public class CollectionCountValueAssertion<TItem> : Sources.ValueAssertion<int>
+public class CollectionCountValueAssertion<TCollection, TItem> : Sources.ValueAssertion<int>
+    where TCollection : IEnumerable<TItem>
 {
     public CollectionCountValueAssertion(
-        AssertionContext<IEnumerable<TItem>> collectionContext,
+        AssertionContext<TCollection> collectionContext,
         Func<TItem, bool>? predicate)
         : base(CreateIntContext(collectionContext, predicate))
     {
     }
 
     private static AssertionContext<int> CreateIntContext(
-        AssertionContext<IEnumerable<TItem>> collectionContext,
+        AssertionContext<TCollection> collectionContext,
         Func<TItem, bool>? predicate)
     {
         return collectionContext.Map<int>(collection =>
diff --git a/TUnit.Assertions/Conditions/IsEquivalentToAssertion.cs b/TUnit.Assertions/Conditions/IsEquivalentToAssertion.cs
index 1ea55434c3..ec82f1e13f 100644
--- a/TUnit.Assertions/Conditions/IsEquivalentToAssertion.cs
+++ b/TUnit.Assertions/Conditions/IsEquivalentToAssertion.cs
@@ -15,13 +15,14 @@ namespace TUnit.Assertions.Conditions;
 /// </summary>
 [AssertionExtension("IsEquivalentTo")]
 [RequiresDynamicCode("Collection equivalency uses structural comparison for complex objects, which requires reflection and is not compatible with AOT")]
-public class IsEquivalentToAssertion<TItem> : CollectionComparerBasedAssertion<TItem>
+public class IsEquivalentToAssertion<TCollection, TItem> : CollectionComparerBasedAssertion<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly IEnumerable<TItem> _expected;
     private readonly CollectionOrdering _ordering;
 
     public IsEquivalentToAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         IEnumerable<TItem> expected,
         CollectionOrdering ordering = CollectionOrdering.Any)
         : base(context)
@@ -31,7 +32,7 @@ public IsEquivalentToAssertion(
     }
 
     public IsEquivalentToAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         IEnumerable<TItem> expected,
         IEqualityComparer<TItem> comparer,
         CollectionOrdering ordering = CollectionOrdering.Any)
@@ -42,14 +43,14 @@ public IsEquivalentToAssertion(
         SetComparer(comparer);
     }
 
-    public IsEquivalentToAssertion<TItem> Using(IEqualityComparer<TItem> comparer)
+    public IsEquivalentToAssertion<TCollection, TItem> Using(IEqualityComparer<TItem> comparer)
     {
         SetComparer(comparer);
         return this;
     }
 
     [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Collection equivalency uses structural comparison which requires reflection")]
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
diff --git a/TUnit.Assertions/Conditions/NotEquivalentToAssertion.cs b/TUnit.Assertions/Conditions/NotEquivalentToAssertion.cs
index e10e1ca2af..66444cef0d 100644
--- a/TUnit.Assertions/Conditions/NotEquivalentToAssertion.cs
+++ b/TUnit.Assertions/Conditions/NotEquivalentToAssertion.cs
@@ -14,13 +14,14 @@ namespace TUnit.Assertions.Conditions;
 /// </summary>
 [AssertionExtension("IsNotEquivalentTo")]
 [RequiresDynamicCode("Collection equivalency uses structural comparison for complex objects, which requires reflection and is not compatible with AOT")]
-public class NotEquivalentToAssertion<TItem> : CollectionComparerBasedAssertion<TItem>
+public class NotEquivalentToAssertion<TCollection, TItem> : CollectionComparerBasedAssertion<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
     private readonly IEnumerable<TItem> _notExpected;
     private readonly CollectionOrdering _ordering;
 
     public NotEquivalentToAssertion(
-        AssertionContext<IEnumerable<TItem>> context,
+        AssertionContext<TCollection> context,
         IEnumerable<TItem> notExpected,
         CollectionOrdering ordering = CollectionOrdering.Any)
         : base(context)
@@ -29,14 +30,14 @@ public NotEquivalentToAssertion(
         _ordering = ordering;
     }
 
-    public NotEquivalentToAssertion<TItem> Using(IEqualityComparer<TItem> comparer)
+    public NotEquivalentToAssertion<TCollection, TItem> Using(IEqualityComparer<TItem> comparer)
     {
         SetComparer(comparer);
         return this;
     }
 
     [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Collection equivalency uses structural comparison which requires reflection")]
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IEnumerable<TItem>> metadata)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         var value = metadata.Value;
         var exception = metadata.Exception;
diff --git a/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs b/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs
index b00328c823..82001dcb70 100644
--- a/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs
+++ b/TUnit.Assertions/Conditions/Wrappers/CountWrapper.cs
@@ -10,26 +10,27 @@ namespace TUnit.Assertions.Conditions.Wrappers;
 /// Wrapper for collection count assertions that provides .EqualTo() method.
 /// Example: await Assert.That(list).Count().EqualTo(5);
 /// </summary>
-public class CountWrapper<TItem> : IAssertionSource<IEnumerable<TItem>>
+public class CountWrapper<TCollection, TItem> : IAssertionSource<TCollection>
+    where TCollection : IEnumerable<TItem>
 {
-    private readonly AssertionContext<IEnumerable<TItem>> _context;
+    private readonly AssertionContext<TCollection> _context;
 
-    public CountWrapper(AssertionContext<IEnumerable<TItem>> context)
+    public CountWrapper(AssertionContext<TCollection> context)
     {
         _context = context;
     }
 
-    AssertionContext<IEnumerable<TItem>> IAssertionSource<IEnumerable<TItem>>.Context => _context;
+    AssertionContext<TCollection> IAssertionSource<TCollection>.Context => _context;
 
     /// <summary>
     /// Asserts that the collection count is equal to the expected count.
     /// </summary>
-    public CollectionCountAssertion<TItem> EqualTo(
+    public CollectionCountAssertion<TCollection, TItem> EqualTo(
         int expectedCount,
         [CallerArgumentExpression(nameof(expectedCount))] string? expression = null)
     {
         _context.ExpressionBuilder.Append($".EqualTo({expression})");
-        return new CollectionCountAssertion<TItem>(_context, expectedCount);
+        return new CollectionCountAssertion<TCollection, TItem>(_context, expectedCount);
     }
 
     /// <summary>
@@ -191,10 +192,10 @@ public BetweenAssertion<int> Between(
     /// <summary>
     /// Asserts that the collection count is zero (empty collection).
     /// </summary>
-    public CollectionCountAssertion<TItem> Zero()
+    public CollectionCountAssertion<TCollection, TItem> Zero()
     {
         _context.ExpressionBuilder.Append(".Zero()");
-        return new CollectionCountAssertion<TItem>(_context, 0);
+        return new CollectionCountAssertion<TCollection, TItem>(_context, 0);
     }
 
     /// <summary>
diff --git a/TUnit.Assertions/Core/CollectionContinuations.cs b/TUnit.Assertions/Core/CollectionContinuations.cs
index c8022eb8fc..2dca92392c 100644
--- a/TUnit.Assertions/Core/CollectionContinuations.cs
+++ b/TUnit.Assertions/Core/CollectionContinuations.cs
@@ -4,24 +4,26 @@
 namespace TUnit.Assertions.Core;
 
 /// <summary>
-/// And continuation for collection assertions that preserves item type.
+/// And continuation for collection assertions that preserves collection type and item type.
 /// Inherits from CollectionAssertionBase to automatically expose all collection methods.
 /// </summary>
-public class CollectionAndContinuation<TItem> : CollectionAssertionBase<TItem>
+public class CollectionAndContinuation<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
-    internal CollectionAndContinuation(AssertionContext<IEnumerable<TItem>> context, Assertion<IEnumerable<TItem>> previousAssertion)
+    internal CollectionAndContinuation(AssertionContext<TCollection> context, Assertion<TCollection> previousAssertion)
         : base(context, previousAssertion, ".And", CombinerType.And)
     {
     }
 }
 
 /// <summary>
-/// Or continuation for collection assertions that preserves item type.
+/// Or continuation for collection assertions that preserves collection type and item type.
 /// Inherits from CollectionAssertionBase to automatically expose all collection methods.
 /// </summary>
-public class CollectionOrContinuation<TItem> : CollectionAssertionBase<TItem>
+public class CollectionOrContinuation<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
 {
-    internal CollectionOrContinuation(AssertionContext<IEnumerable<TItem>> context, Assertion<IEnumerable<TItem>> previousAssertion)
+    internal CollectionOrContinuation(AssertionContext<TCollection> context, Assertion<TCollection> previousAssertion)
         : base(context, previousAssertion, ".Or", CombinerType.Or)
     {
     }
diff --git a/TUnit.Assertions/Sources/CollectionAssertion.cs b/TUnit.Assertions/Sources/CollectionAssertion.cs
index 2b00182b74..25b1861d19 100644
--- a/TUnit.Assertions/Sources/CollectionAssertion.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertion.cs
@@ -10,7 +10,7 @@ namespace TUnit.Assertions.Sources;
 /// Inherits from CollectionAssertionBase to get all collection-specific instance methods (Contains, IsInOrder, etc.)
 /// that persist through And/Or continuations.
 /// </summary>
-public class CollectionAssertion<TItem> : CollectionAssertionBase<TItem>
+public class CollectionAssertion<TItem> : CollectionAssertionBase<IEnumerable<TItem>, TItem>
 {
     public CollectionAssertion(IEnumerable<TItem> value, string? expression)
         : base(new AssertionContext<IEnumerable<TItem>>(value, CreateExpressionBuilder(expression)))
diff --git a/TUnit.Assertions/Sources/CollectionAssertionBase.cs b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
index 4c6cecc4ca..a67a5878ee 100644
--- a/TUnit.Assertions/Sources/CollectionAssertionBase.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
@@ -8,18 +8,20 @@ namespace TUnit.Assertions.Sources;
 
 /// <summary>
 /// Base class for all collection assertions that preserves type through And/Or chains.
-/// Implements IAssertionSource&lt;IEnumerable&lt;TItem&gt;&gt; to enable all collection and value extension methods.
+/// Implements IAssertionSource&lt;TCollection&gt; to enable all collection and value extension methods.
 /// All collection-specific operations (Contains, IsInOrder, etc.) are provided as instance methods.
 /// </summary>
+/// <typeparam name="TCollection">The concrete collection type (e.g., IEnumerable&lt;T&gt;, IReadOnlyDictionary&lt;K,V&gt;)</typeparam>
 /// <typeparam name="TItem">The type of items in the collection</typeparam>
-public abstract class CollectionAssertionBase<TItem> : Assertion<IEnumerable<TItem>>, IAssertionSource<IEnumerable<TItem>>
+public abstract class CollectionAssertionBase<TCollection, TItem> : Assertion<TCollection>, IAssertionSource<TCollection>
+    where TCollection : IEnumerable<TItem>
 {
     /// <summary>
     /// Explicit implementation of IAssertionSource.Context to expose the context publicly.
     /// </summary>
-    AssertionContext<IEnumerable<TItem>> IAssertionSource<IEnumerable<TItem>>.Context => Context;
+    AssertionContext<TCollection> IAssertionSource<TCollection>.Context => Context;
 
-    protected CollectionAssertionBase(AssertionContext<IEnumerable<TItem>> context)
+    protected CollectionAssertionBase(AssertionContext<TCollection> context)
         : base(context)
     {
     }
@@ -30,8 +32,8 @@ protected CollectionAssertionBase(AssertionContext<IEnumerable<TItem>> context)
     /// Private protected means accessible only to derived classes within the same assembly.
     /// </summary>
     private protected CollectionAssertionBase(
-        AssertionContext<IEnumerable<TItem>> context,
-        Assertion<IEnumerable<TItem>> previousAssertion,
+        AssertionContext<TCollection> context,
+        Assertion<TCollection> previousAssertion,
         string combinerExpression,
         CombinerType combinerType)
         : base(context)
@@ -47,10 +49,10 @@ private protected CollectionAssertionBase(
     /// This instance method allows single type parameter usage without needing to specify the source type.
     /// Example: await Assert.That(readOnlyList).IsTypeOf&lt;List&lt;double&gt;&gt;();
     /// </summary>
-    public TypeOfAssertion<IEnumerable<TItem>, TExpected> IsTypeOf<TExpected>()
+    public TypeOfAssertion<TCollection, TExpected> IsTypeOf<TExpected>()
     {
         Context.ExpressionBuilder.Append($".IsTypeOf<{typeof(TExpected).Name}>()");
-        return new TypeOfAssertion<IEnumerable<TItem>, TExpected>(Context);
+        return new TypeOfAssertion<TCollection, TExpected>(Context);
     }
 
     /// <summary>
@@ -58,12 +60,12 @@ public TypeOfAssertion<IEnumerable<TItem>, TExpected> IsTypeOf<TExpected>()
     /// This instance method enables calling Contains with proper type inference.
     /// Example: await Assert.That(list).Contains("value");
     /// </summary>
-    public CollectionContainsAssertion<TItem> Contains(
+    public CollectionContainsAssertion<TCollection, TItem> Contains(
         TItem expected,
         [CallerArgumentExpression(nameof(expected))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".Contains({expression})");
-        return new CollectionContainsAssertion<TItem>(Context, expected);
+        return new CollectionContainsAssertion<TCollection, TItem>(Context, expected);
     }
 
     /// <summary>
@@ -71,12 +73,12 @@ public CollectionContainsAssertion<TItem> Contains(
     /// This instance method enables calling Contains with proper type inference.
     /// Example: await Assert.That(list).Contains(x => x > 5);
     /// </summary>
-    public CollectionContainsPredicateAssertion<TItem> Contains(
+    public CollectionContainsPredicateAssertion<TCollection, TItem> Contains(
         Func<TItem, bool> predicate,
         [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".Contains({expression})");
-        return new CollectionContainsPredicateAssertion<TItem>(Context, predicate);
+        return new CollectionContainsPredicateAssertion<TCollection, TItem>(Context, predicate);
     }
 
     /// <summary>
@@ -84,12 +86,12 @@ public CollectionContainsPredicateAssertion<TItem> Contains(
     /// This instance method enables calling HasCount with proper type inference.
     /// Example: await Assert.That(list).HasCount(5);
     /// </summary>
-    public CollectionCountAssertion<TItem> HasCount(
+    public CollectionCountAssertion<TCollection, TItem> HasCount(
         int expectedCount,
         [CallerArgumentExpression(nameof(expectedCount))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".HasCount({expression})");
-        return new CollectionCountAssertion<TItem>(Context, expectedCount);
+        return new CollectionCountAssertion<TCollection, TItem>(Context, expectedCount);
     }
 
     /// <summary>
@@ -97,10 +99,10 @@ public CollectionCountAssertion<TItem> HasCount(
     /// This enables the pattern: .HasCount().GreaterThan(5)
     /// Example: await Assert.That(list).HasCount().EqualTo(5);
     /// </summary>
-    public CountWrapper<TItem> HasCount()
+    public CountWrapper<TCollection, TItem> HasCount()
     {
         Context.ExpressionBuilder.Append(".HasCount()");
-        return new CountWrapper<TItem>(Context);
+        return new CountWrapper<TCollection, TItem>(Context);
     }
 
     /// <summary>
@@ -108,10 +110,10 @@ public CountWrapper<TItem> HasCount()
     /// This enables fluent assertions on the count itself.
     /// Example: await Assert.That(list).Count().IsGreaterThan(5);
     /// </summary>
-    public CollectionCountValueAssertion<TItem> Count()
+    public CollectionCountValueAssertion<TCollection, TItem> Count()
     {
         Context.ExpressionBuilder.Append(".Count()");
-        return new CollectionCountValueAssertion<TItem>(Context, null);
+        return new CollectionCountValueAssertion<TCollection, TItem>(Context, null);
     }
 
     /// <summary>
@@ -119,12 +121,12 @@ public CollectionCountValueAssertion<TItem> Count()
     /// This enables fluent assertions on filtered counts.
     /// Example: await Assert.That(list).Count(x => x > 10).IsEqualTo(3);
     /// </summary>
-    public CollectionCountValueAssertion<TItem> Count(
+    public CollectionCountValueAssertion<TCollection, TItem> Count(
         Func<TItem, bool> predicate,
         [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".Count({expression})");
-        return new CollectionCountValueAssertion<TItem>(Context, predicate);
+        return new CollectionCountValueAssertion<TCollection, TItem>(Context, predicate);
     }
 
     /// <summary>
@@ -132,12 +134,12 @@ public CollectionCountValueAssertion<TItem> Count(
     /// This instance method enables calling IsOrderedBy with proper type inference.
     /// Example: await Assert.That(list).IsOrderedBy(x => x.Name);
     /// </summary>
-    public CollectionIsOrderedByAssertion<TItem, TKey> IsOrderedBy<TKey>(
+    public CollectionIsOrderedByAssertion<TCollection, TItem, TKey> IsOrderedBy<TKey>(
         Func<TItem, TKey> keySelector,
         [CallerArgumentExpression(nameof(keySelector))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".IsOrderedBy({expression})");
-        return new CollectionIsOrderedByAssertion<TItem, TKey>(Context, keySelector);
+        return new CollectionIsOrderedByAssertion<TCollection, TItem, TKey>(Context, keySelector);
     }
 
     /// <summary>
@@ -145,14 +147,14 @@ public CollectionIsOrderedByAssertion<TItem, TKey> IsOrderedBy<TKey>(
     /// This instance method enables calling IsOrderedBy with proper type inference.
     /// Example: await Assert.That(list).IsOrderedBy(x => x.Name, StringComparer.OrdinalIgnoreCase);
     /// </summary>
-    public CollectionIsOrderedByAssertion<TItem, TKey> IsOrderedBy<TKey>(
+    public CollectionIsOrderedByAssertion<TCollection, TItem, TKey> IsOrderedBy<TKey>(
         Func<TItem, TKey> keySelector,
         IComparer<TKey>? comparer,
         [CallerArgumentExpression(nameof(keySelector))] string? selectorExpression = null,
         [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
     {
         Context.ExpressionBuilder.Append($".IsOrderedBy({selectorExpression}, {comparerExpression})");
-        return new CollectionIsOrderedByAssertion<TItem, TKey>(Context, keySelector, comparer);
+        return new CollectionIsOrderedByAssertion<TCollection, TItem, TKey>(Context, keySelector, comparer);
     }
 
     /// <summary>
@@ -160,12 +162,12 @@ public CollectionIsOrderedByAssertion<TItem, TKey> IsOrderedBy<TKey>(
     /// This instance method enables calling IsOrderedByDescending with proper type inference.
     /// Example: await Assert.That(list).IsOrderedByDescending(x => x.Age);
     /// </summary>
-    public CollectionIsOrderedByDescendingAssertion<TItem, TKey> IsOrderedByDescending<TKey>(
+    public CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(
         Func<TItem, TKey> keySelector,
         [CallerArgumentExpression(nameof(keySelector))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".IsOrderedByDescending({expression})");
-        return new CollectionIsOrderedByDescendingAssertion<TItem, TKey>(Context, keySelector);
+        return new CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey>(Context, keySelector);
     }
 
     /// <summary>
@@ -173,14 +175,14 @@ public CollectionIsOrderedByDescendingAssertion<TItem, TKey> IsOrderedByDescendi
     /// This instance method enables calling IsOrderedByDescending with proper type inference.
     /// Example: await Assert.That(list).IsOrderedByDescending(x => x.Name, StringComparer.OrdinalIgnoreCase);
     /// </summary>
-    public CollectionIsOrderedByDescendingAssertion<TItem, TKey> IsOrderedByDescending<TKey>(
+    public CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(
         Func<TItem, TKey> keySelector,
         IComparer<TKey>? comparer,
         [CallerArgumentExpression(nameof(keySelector))] string? selectorExpression = null,
         [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
     {
         Context.ExpressionBuilder.Append($".IsOrderedByDescending({selectorExpression}, {comparerExpression})");
-        return new CollectionIsOrderedByDescendingAssertion<TItem, TKey>(Context, keySelector, comparer);
+        return new CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey>(Context, keySelector, comparer);
     }
 
     /// <summary>
@@ -188,10 +190,10 @@ public CollectionIsOrderedByDescendingAssertion<TItem, TKey> IsOrderedByDescendi
     /// This instance method enables calling IsEmpty with proper type inference.
     /// Example: await Assert.That(list).IsEmpty();
     /// </summary>
-    public CollectionIsEmptyAssertion<TItem> IsEmpty()
+    public CollectionIsEmptyAssertion<TCollection, TItem> IsEmpty()
     {
         Context.ExpressionBuilder.Append(".IsEmpty()");
-        return new CollectionIsEmptyAssertion<TItem>(Context);
+        return new CollectionIsEmptyAssertion<TCollection, TItem>(Context);
     }
 
     /// <summary>
@@ -199,10 +201,10 @@ public CollectionIsEmptyAssertion<TItem> IsEmpty()
     /// This instance method enables calling IsNotEmpty with proper type inference.
     /// Example: await Assert.That(list).IsNotEmpty();
     /// </summary>
-    public CollectionIsNotEmptyAssertion<TItem> IsNotEmpty()
+    public CollectionIsNotEmptyAssertion<TCollection, TItem> IsNotEmpty()
     {
         Context.ExpressionBuilder.Append(".IsNotEmpty()");
-        return new CollectionIsNotEmptyAssertion<TItem>(Context);
+        return new CollectionIsNotEmptyAssertion<TCollection, TItem>(Context);
     }
 
     /// <summary>
@@ -210,10 +212,10 @@ public CollectionIsNotEmptyAssertion<TItem> IsNotEmpty()
     /// This instance method enables calling HasSingleItem with proper type inference.
     /// Example: await Assert.That(list).HasSingleItem();
     /// </summary>
-    public HasSingleItemAssertion<TItem> HasSingleItem()
+    public HasSingleItemAssertion<TCollection, TItem> HasSingleItem()
     {
         Context.ExpressionBuilder.Append(".HasSingleItem()");
-        return new HasSingleItemAssertion<TItem>(Context);
+        return new HasSingleItemAssertion<TCollection, TItem>(Context);
     }
 
     /// <summary>
@@ -221,12 +223,12 @@ public HasSingleItemAssertion<TItem> HasSingleItem()
     /// This instance method enables calling DoesNotContain with proper type inference.
     /// Example: await Assert.That(list).DoesNotContain("value");
     /// </summary>
-    public CollectionDoesNotContainAssertion<TItem> DoesNotContain(
+    public CollectionDoesNotContainAssertion<TCollection, TItem> DoesNotContain(
         TItem expected,
         [CallerArgumentExpression(nameof(expected))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".DoesNotContain({expression})");
-        return new CollectionDoesNotContainAssertion<TItem>(Context, expected);
+        return new CollectionDoesNotContainAssertion<TCollection, TItem>(Context, expected);
     }
 
     /// <summary>
@@ -234,12 +236,12 @@ public CollectionDoesNotContainAssertion<TItem> DoesNotContain(
     /// This instance method enables calling DoesNotContain with proper type inference.
     /// Example: await Assert.That(list).DoesNotContain(x => x > 10);
     /// </summary>
-    public CollectionDoesNotContainPredicateAssertion<TItem> DoesNotContain(
+    public CollectionDoesNotContainPredicateAssertion<TCollection, TItem> DoesNotContain(
         Func<TItem, bool> predicate,
         [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".DoesNotContain({expression})");
-        return new CollectionDoesNotContainPredicateAssertion<TItem>(Context, predicate, expression ?? "predicate");
+        return new CollectionDoesNotContainPredicateAssertion<TCollection, TItem>(Context, predicate, expression ?? "predicate");
     }
 
     /// <summary>
@@ -247,12 +249,12 @@ public CollectionDoesNotContainPredicateAssertion<TItem> DoesNotContain(
     /// This instance method enables calling All with proper type inference.
     /// Example: await Assert.That(list).All(x => x > 0);
     /// </summary>
-    public CollectionAllAssertion<TItem> All(
+    public CollectionAllAssertion<TCollection, TItem> All(
         Func<TItem, bool> predicate,
         [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".All({expression})");
-        return new CollectionAllAssertion<TItem>(Context, predicate, expression ?? "predicate");
+        return new CollectionAllAssertion<TCollection, TItem>(Context, predicate, expression ?? "predicate");
     }
 
     /// <summary>
@@ -260,10 +262,10 @@ public CollectionAllAssertion<TItem> All(
     /// This instance method enables calling All().Satisfy() with proper type inference.
     /// Example: await Assert.That(list).All().Satisfy(item => item.IsNotNull());
     /// </summary>
-    public CollectionAllSatisfyHelper<TItem> All()
+    public CollectionAllSatisfyHelper<TCollection, TItem> All()
     {
         Context.ExpressionBuilder.Append(".All()");
-        return new CollectionAllSatisfyHelper<TItem>(Context);
+        return new CollectionAllSatisfyHelper<TCollection, TItem>(Context);
     }
 
     /// <summary>
@@ -271,12 +273,12 @@ public CollectionAllSatisfyHelper<TItem> All()
     /// This instance method enables calling Any with proper type inference.
     /// Example: await Assert.That(list).Any(x => x > 10);
     /// </summary>
-    public CollectionAnyAssertion<TItem> Any(
+    public CollectionAnyAssertion<TCollection, TItem> Any(
         Func<TItem, bool> predicate,
         [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".Any({expression})");
-        return new CollectionAnyAssertion<TItem>(Context, predicate, expression ?? "predicate");
+        return new CollectionAnyAssertion<TCollection, TItem>(Context, predicate, expression ?? "predicate");
     }
 
     /// <summary>
@@ -284,12 +286,12 @@ public CollectionAnyAssertion<TItem> Any(
     /// This instance method enables calling ContainsOnly with proper type inference.
     /// Example: await Assert.That(list).ContainsOnly(x => x > 0);
     /// </summary>
-    public CollectionAllAssertion<TItem> ContainsOnly(
+    public CollectionAllAssertion<TCollection, TItem> ContainsOnly(
         Func<TItem, bool> predicate,
         [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
         Context.ExpressionBuilder.Append($".ContainsOnly({expression})");
-        return new CollectionAllAssertion<TItem>(Context, predicate, expression ?? "predicate");
+        return new CollectionAllAssertion<TCollection, TItem>(Context, predicate, expression ?? "predicate");
     }
 
     /// <summary>
@@ -298,10 +300,10 @@ public CollectionAllAssertion<TItem> ContainsOnly(
     /// Uses runtime comparison via Comparer&lt;TItem&gt;.Default.
     /// Example: await Assert.That(list).IsInOrder();
     /// </summary>
-    public CollectionIsInOrderAssertion<TItem> IsInOrder()
+    public CollectionIsInOrderAssertion<TCollection, TItem> IsInOrder()
     {
         Context.ExpressionBuilder.Append(".IsInOrder()");
-        return new CollectionIsInOrderAssertion<TItem>(Context);
+        return new CollectionIsInOrderAssertion<TCollection, TItem>(Context);
     }
 
     /// <summary>
@@ -310,22 +312,22 @@ public CollectionIsInOrderAssertion<TItem> IsInOrder()
     /// Uses runtime comparison via Comparer&lt;TItem&gt;.Default.
     /// Example: await Assert.That(list).IsInDescendingOrder();
     /// </summary>
-    public CollectionIsInDescendingOrderAssertion<TItem> IsInDescendingOrder()
+    public CollectionIsInDescendingOrderAssertion<TCollection, TItem> IsInDescendingOrder()
     {
         Context.ExpressionBuilder.Append(".IsInDescendingOrder()");
-        return new CollectionIsInDescendingOrderAssertion<TItem>(Context);
+        return new CollectionIsInDescendingOrderAssertion<TCollection, TItem>(Context);
     }
 
     /// <summary>
     /// Returns an And continuation that preserves collection type and item type.
     /// Overrides the base Assertion.And to return a collection-specific continuation.
     /// </summary>
-    public new CollectionAndContinuation<TItem> And
+    public new CollectionAndContinuation<TCollection, TItem> And
     {
         get
         {
-            ThrowIfMixingCombiner<Chaining.OrAssertion<IEnumerable<TItem>>>();
-            return new CollectionAndContinuation<TItem>(Context, InternalWrappedExecution ?? this);
+            ThrowIfMixingCombiner<Chaining.OrAssertion<TCollection>>();
+            return new CollectionAndContinuation<TCollection, TItem>(Context, InternalWrappedExecution ?? this);
         }
     }
 
@@ -333,12 +335,12 @@ public CollectionIsInDescendingOrderAssertion<TItem> IsInDescendingOrder()
     /// Returns an Or continuation that preserves collection type and item type.
     /// Overrides the base Assertion.Or to return a collection-specific continuation.
     /// </summary>
-    public new CollectionOrContinuation<TItem> Or
+    public new CollectionOrContinuation<TCollection, TItem> Or
     {
         get
         {
-            ThrowIfMixingCombiner<Chaining.AndAssertion<IEnumerable<TItem>>>();
-            return new CollectionOrContinuation<TItem>(Context, InternalWrappedExecution ?? this);
+            ThrowIfMixingCombiner<Chaining.AndAssertion<TCollection>>();
+            return new CollectionOrContinuation<TCollection, TItem>(Context, InternalWrappedExecution ?? this);
         }
     }
 }
diff --git a/TUnit.Assertions/Sources/DictionaryAssertionBase.cs b/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
index f40be0c5c8..b5077d1b43 100644
--- a/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
@@ -7,20 +7,15 @@ namespace TUnit.Assertions.Sources;
 
 /// <summary>
 /// Base class for dictionary assertions that preserves type through And/Or chains.
-/// Implements IAssertionSource&lt;TDictionary&gt; to enable all collection and dictionary extension methods.
-/// Since dictionaries are collections of KeyValuePair items, collection assertions also work on dictionaries.
+/// Inherits from CollectionAssertionBase to automatically get all collection methods (HasSingleItem, IsInOrder, etc.)
+/// since dictionaries are collections of KeyValuePair items.
 /// </summary>
 /// <typeparam name="TDictionary">The dictionary type (e.g., Dictionary, IReadOnlyDictionary)</typeparam>
 /// <typeparam name="TKey">The dictionary key type</typeparam>
 /// <typeparam name="TValue">The dictionary value type</typeparam>
-public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : Assertion<TDictionary>, IAssertionSource<TDictionary>
+public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : CollectionAssertionBase<TDictionary, KeyValuePair<TKey, TValue>>
     where TDictionary : IReadOnlyDictionary<TKey, TValue>
 {
-    /// <summary>
-    /// Explicit implementation of IAssertionSource.Context to expose the context publicly.
-    /// </summary>
-    AssertionContext<TDictionary> IAssertionSource<TDictionary>.Context => Context;
-
     protected DictionaryAssertionBase(AssertionContext<TDictionary> context)
         : base(context)
     {
@@ -36,10 +31,8 @@ private protected DictionaryAssertionBase(
         Assertion<TDictionary> previousAssertion,
         string combinerExpression,
         CombinerType combinerType)
-        : base(context)
+        : base(context, previousAssertion, combinerExpression, combinerType)
     {
-        context.ExpressionBuilder.Append(combinerExpression);
-        context.SetPendingLink(previousAssertion, combinerType);
     }
 
     protected override string GetExpectation() => "dictionary assertion";
@@ -85,115 +78,6 @@ public DictionaryDoesNotContainKeyAssertion<TDictionary, TKey, TValue> DoesNotCo
         return new DictionaryDoesNotContainKeyAssertion<TDictionary, TKey, TValue>(Context, expectedKey);
     }
 
-    /// <summary>
-    /// Asserts that the dictionary is empty (has no key-value pairs).
-    /// This instance method enables calling IsEmpty with proper type inference.
-    /// Example: await Assert.That(dictionary).IsEmpty();
-    /// </summary>
-    public CollectionIsEmptyAssertion<KeyValuePair<TKey, TValue>> IsEmpty()
-    {
-        Context.ExpressionBuilder.Append(".IsEmpty()");
-        return new CollectionIsEmptyAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict));
-    }
-
-    /// <summary>
-    /// Asserts that the dictionary is not empty (has at least one key-value pair).
-    /// This instance method enables calling IsNotEmpty with proper type inference.
-    /// Example: await Assert.That(dictionary).IsNotEmpty();
-    /// </summary>
-    public CollectionIsNotEmptyAssertion<KeyValuePair<TKey, TValue>> IsNotEmpty()
-    {
-        Context.ExpressionBuilder.Append(".IsNotEmpty()");
-        return new CollectionIsNotEmptyAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict));
-    }
-
-    /// <summary>
-    /// Asserts that the dictionary contains the specified key-value pair.
-    /// This instance method enables calling Contains with proper type inference.
-    /// Example: await Assert.That(dictionary).Contains(new KeyValuePair&lt;string, int&gt;("key", 1));
-    /// </summary>
-    public CollectionContainsAssertion<KeyValuePair<TKey, TValue>> Contains(
-        KeyValuePair<TKey, TValue> expected,
-        [CallerArgumentExpression(nameof(expected))] string? expression = null)
-    {
-        Context.ExpressionBuilder.Append($".Contains({expression})");
-        return new CollectionContainsAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict), expected);
-    }
-
-    /// <summary>
-    /// Asserts that the dictionary contains a key-value pair matching the predicate.
-    /// This instance method enables calling Contains with proper type inference.
-    /// Example: await Assert.That(dictionary).Contains(kvp => kvp.Value > 10);
-    /// </summary>
-    public CollectionContainsPredicateAssertion<KeyValuePair<TKey, TValue>> Contains(
-        Func<KeyValuePair<TKey, TValue>, bool> predicate,
-        [CallerArgumentExpression(nameof(predicate))] string? expression = null)
-    {
-        Context.ExpressionBuilder.Append($".Contains({expression})");
-        return new CollectionContainsPredicateAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict), predicate);
-    }
-
-    /// <summary>
-    /// Asserts that all key-value pairs in the dictionary satisfy the predicate.
-    /// This instance method enables calling All with proper type inference.
-    /// Example: await Assert.That(dictionary).All(kvp => kvp.Value > 0);
-    /// </summary>
-    public CollectionAllAssertion<KeyValuePair<TKey, TValue>> All(
-        Func<KeyValuePair<TKey, TValue>, bool> predicate,
-        [CallerArgumentExpression(nameof(predicate))] string? expression = null)
-    {
-        Context.ExpressionBuilder.Append($".All({expression})");
-        return new CollectionAllAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict), predicate, expression ?? "predicate");
-    }
-
-    /// <summary>
-    /// Returns a helper for the .All().Satisfy() pattern on dictionaries.
-    /// This instance method enables calling All().Satisfy() with proper type inference.
-    /// Example: await Assert.That(dictionary).All().Satisfy(kvp => kvp.Value.IsNotNull());
-    /// </summary>
-    public CollectionAllSatisfyHelper<KeyValuePair<TKey, TValue>> All()
-    {
-        Context.ExpressionBuilder.Append(".All()");
-        return new CollectionAllSatisfyHelper<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict));
-    }
-
-    /// <summary>
-    /// Asserts that at least one key-value pair in the dictionary satisfies the predicate.
-    /// This instance method enables calling Any with proper type inference.
-    /// Example: await Assert.That(dictionary).Any(kvp => kvp.Value > 100);
-    /// </summary>
-    public CollectionAnyAssertion<KeyValuePair<TKey, TValue>> Any(
-        Func<KeyValuePair<TKey, TValue>, bool> predicate,
-        [CallerArgumentExpression(nameof(predicate))] string? expression = null)
-    {
-        Context.ExpressionBuilder.Append($".Any({expression})");
-        return new CollectionAnyAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict), predicate, expression ?? "predicate");
-    }
-
-    /// <summary>
-    /// Asserts that the dictionary has the expected number of key-value pairs.
-    /// This instance method enables calling HasCount with proper type inference.
-    /// Example: await Assert.That(dictionary).HasCount(5);
-    /// </summary>
-    public CollectionCountAssertion<KeyValuePair<TKey, TValue>> HasCount(
-        int expectedCount,
-        [CallerArgumentExpression(nameof(expectedCount))] string? expression = null)
-    {
-        Context.ExpressionBuilder.Append($".HasCount({expression})");
-        return new CollectionCountAssertion<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict), expectedCount);
-    }
-
-    /// <summary>
-    /// Returns a wrapper for fluent count assertions on dictionaries.
-    /// This enables the pattern: .HasCount().GreaterThan(5)
-    /// Example: await Assert.That(dictionary).HasCount().EqualTo(5);
-    /// </summary>
-    public CountWrapper<KeyValuePair<TKey, TValue>> HasCount()
-    {
-        Context.ExpressionBuilder.Append(".HasCount()");
-        return new CountWrapper<KeyValuePair<TKey, TValue>>(Context.Map<IEnumerable<KeyValuePair<TKey, TValue>>>(dict => dict));
-    }
-
     /// <summary>
     /// Returns an And continuation that preserves dictionary type, key type, and value type.
     /// Overrides the base Assertion.And to return a dictionary-specific continuation.
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
index cf53b41e7f..02dcf51778 100644
--- 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
@@ -367,122 +367,140 @@ namespace .Conditions
     [.<char>("IsWhiteSpace", ExpectationMessage="be whitespace")]
     public static class CharAssertionExtensions { }
     [.("All")]
-    public class CollectionAllAssertion<TItem> : .<TItem>
+    public class CollectionAllAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyAssertion<TItem> : .<TItem>
+    public class CollectionAllSatisfyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyAssertion(.<.<TItem>> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyAssertion(.<TCollection> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyHelper<TItem>
+    public class CollectionAllSatisfyHelper<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyHelper(.<.<TItem>> context) { }
-        public .<TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
-        public .<TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
+        public CollectionAllSatisfyHelper(.<TCollection> context) { }
+        public .<TCollection, TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TCollection, TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
     }
-    public class CollectionAllSatisfyMappedAssertion<TItem, TMapped> : .<TItem>
+    public class CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyMappedAssertion(.<.<TItem>> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyMappedAssertion(.<TCollection> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Any")]
-    public class CollectionAnyAssertion<TItem> : .<TItem>
+    public class CollectionAnyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAnyAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAnyAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public abstract class CollectionComparerBasedAssertion<TItem> : .<TItem>
+    public abstract class CollectionComparerBasedAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        protected CollectionComparerBasedAssertion(.<.<TItem>> context) { }
+        protected CollectionComparerBasedAssertion(.<TCollection> context) { }
         protected .<TItem> GetComparer() { }
         protected bool HasCustomComparer() { }
         protected void SetComparer(.<TItem> comparer) { }
     }
     [.("Contains")]
-    public class CollectionContainsAssertion<TItem> : .<TItem>
+    public class CollectionContainsAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Contains")]
-    public class CollectionContainsPredicateAssertion<TItem> : .<TItem>
+    public class CollectionContainsPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsPredicateAssertion(.<TCollection> context, <TItem, bool> predicate) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
     [.("HasCount")]
-    public class CollectionCountAssertion<TItem> : .<TItem>
+    public class CollectionCountAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionCountAssertion(.<.<TItem>> context, int expectedCount) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionCountAssertion(.<TCollection> context, int expectedCount) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionCountValueAssertion<TItem> : .<int>
+    public class CollectionCountValueAssertion<TCollection, TItem> : .<int>
+        where TCollection : .<TItem>
     {
-        public CollectionCountValueAssertion(.<.<TItem>> collectionContext, <TItem, bool>? predicate) { }
+        public CollectionCountValueAssertion(.<TCollection> collectionContext, <TItem, bool>? predicate) { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainPredicateAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsEmpty")]
-    public class CollectionIsEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInDescendingOrder")]
-    public class CollectionIsInDescendingOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInDescendingOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInDescendingOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInDescendingOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInOrder")]
-    public class CollectionIsInOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsNotEmpty")]
-    public class CollectionIsNotEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsNotEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsNotEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsNotEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByDescendingAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByDescendingAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByDescendingAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
@@ -908,10 +926,11 @@ namespace .Conditions
         protected override string GetExpectation() { }
     }
     [.("HasSingleItem")]
-    public class HasSingleItemAssertion<TItem> : .<TItem>
+    public class HasSingleItemAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public HasSingleItemAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public HasSingleItemAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
@@ -980,14 +999,15 @@ namespace .Conditions
     [.("Collection equivalency uses structural comparison for complex objects, which requ" +
         "ires reflection and is not compatible with AOT")]
     [.("IsEquivalentTo")]
-    public class IsEquivalentToAssertion<TItem> : .<TItem>
+    public class IsEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, . ordering = 0) { }
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
         [.("AOT", "IL3050", Justification="Collection equivalency uses structural comparison which requires reflection")]
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     [.("IsIn")]
     public class IsInAssertion<TValue> : .<TValue, TValue>
@@ -1085,13 +1105,14 @@ namespace .Conditions
     [.("Collection equivalency uses structural comparison for complex objects, which requ" +
         "ires reflection and is not compatible with AOT")]
     [.("IsNotEquivalentTo")]
-    public class NotEquivalentToAssertion<TItem> : .<TItem>
+    public class NotEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public NotEquivalentToAssertion(.<.<TItem>> context, .<TItem> notExpected, . ordering = 0) { }
+        public NotEquivalentToAssertion(.<TCollection> context, .<TItem> notExpected, . ordering = 0) { }
         [.("AOT", "IL3050", Justification="Collection equivalency uses structural comparison which requires reflection")]
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     public class NotNullAssertion<TValue> : .<TValue>
     {
@@ -1528,18 +1549,19 @@ namespace .
 }
 namespace .
 {
-    public class CountWrapper<TItem> : ., .<.<TItem>>
+    public class CountWrapper<TCollection, TItem> : ., .<TCollection>
+        where TCollection : .<TItem>
     {
-        public CountWrapper(.<.<TItem>> context) { }
+        public CountWrapper(.<TCollection> context) { }
         public .<int> Between(int minimum, int maximum, [.("minimum")] string? minExpression = null, [.("maximum")] string? maxExpression = null) { }
-        public .<TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<int> GreaterThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> GreaterThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> NotEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> Positive() { }
-        public .<TItem> Zero() { }
+        public .<TCollection, TItem> Zero() { }
     }
     public class LengthWrapper : ., .<string>
     {
@@ -1601,8 +1623,10 @@ namespace .Core
         And = 1,
         Or = 2,
     }
-    public class CollectionAndContinuation<TItem> : .<TItem> { }
-    public class CollectionOrContinuation<TItem> : .<TItem> { }
+    public class CollectionAndContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
+    public class CollectionOrContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
     public class DictionaryAndContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue> { }
     public class DictionaryOrContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
@@ -2030,47 +2054,58 @@ namespace .Extensions
     }
     public static class CollectionAllAssertionExtensions
     {
-        public static .<TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> All<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionAnyAssertionExtensions
     {
-        public static .<TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> Any<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsPredicateAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionCountAssertionExtensions
     {
-        public static .<TItem> HasCount<TItem>(this .<.<TItem>> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null) { }
+        public static .<TCollection, TItem> HasCount<TCollection, TItem>(this .<TCollection> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainPredicateAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsEmptyAssertionExtensions
     {
-        public static .<TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInDescendingOrderAssertionExtensions
     {
-        public static .<TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInDescendingOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInOrderAssertionExtensions
     {
-        public static .<TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsNotEmptyAssertionExtensions
     {
-        public static .<TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsNotEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CultureInfoAssertionExtensions
     {
@@ -2763,7 +2798,8 @@ namespace .Extensions
     }
     public static class HasSingleItemAssertionExtensions
     {
-        public static .<TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> HasSingleItem<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class HttpStatusCodeAssertionExtensions
     {
@@ -2924,10 +2960,12 @@ namespace .Extensions
     {
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class IsInAssertionExtensions
     {
@@ -2990,7 +3028,8 @@ namespace .Extensions
     {
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsNotEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsNotEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class NotSameReferenceAssertionExtensions
     {
@@ -3779,36 +3818,37 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class CollectionAssertionBase<TItem> : .<.<TItem>>, ., .<.<TItem>>
-    {
-        protected CollectionAssertionBase(.<.<TItem>> context) { }
-        public new .<TItem> And { get; }
-        public new .<TItem> Or { get; }
-        public .<TItem> All() { }
-        public .<TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
-        public .<TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Count() { }
-        public .<TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
-        protected override string GetExpectation() { }
-        public ..CountWrapper<TItem> HasCount() { }
-        public .<TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<TItem> HasSingleItem() { }
-        public .<TItem> IsEmpty() { }
-        public .<TItem> IsInDescendingOrder() { }
-        public .<TItem> IsInOrder() { }
-        public .<TItem> IsNotEmpty() { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
-    }
-    public class CollectionAssertion<TItem> : .<TItem>
+    public abstract class CollectionAssertionBase<TCollection, TItem> : .<TCollection>, ., .<TCollection>
+        where TCollection : .<TItem>
+    {
+        protected CollectionAssertionBase(.<TCollection> context) { }
+        public new .<TCollection, TItem> And { get; }
+        public new .<TCollection, TItem> Or { get; }
+        public .<TCollection, TItem> All() { }
+        public .<TCollection, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Count() { }
+        public .<TCollection, TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        protected override string GetExpectation() { }
+        public ..CountWrapper<TCollection, TItem> HasCount() { }
+        public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> HasSingleItem() { }
+        public .<TCollection, TItem> IsEmpty() { }
+        public .<TCollection, TItem> IsInDescendingOrder() { }
+        public .<TCollection, TItem> IsInOrder() { }
+        public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
+    }
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
     }
@@ -3821,25 +3861,16 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary>, ., .<TDictionary>
+    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary, .<TKey, TValue>>
         where TDictionary : .<TKey, TValue>
     {
         protected DictionaryAssertionBase(.<TDictionary> context) { }
         public new .<TDictionary, TKey, TValue> And { get; }
         public new .<TDictionary, TKey, TValue> Or { get; }
-        public .<.<TKey, TValue>> All() { }
-        public .<.<TKey, TValue>> All(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Any(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(.<TKey, TValue> expected, [.("expected")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         protected override string GetExpectation() { }
-        public ..CountWrapper<.<TKey, TValue>> HasCount() { }
-        public .<.<TKey, TValue>> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<.<TKey, TValue>> IsEmpty() { }
-        public .<.<TKey, TValue>> IsNotEmpty() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
     {
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index 81b4f7672e..35f3a409e5 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -364,122 +364,140 @@ namespace .Conditions
     [.<char>("IsWhiteSpace", ExpectationMessage="be whitespace")]
     public static class CharAssertionExtensions { }
     [.("All")]
-    public class CollectionAllAssertion<TItem> : .<TItem>
+    public class CollectionAllAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyAssertion<TItem> : .<TItem>
+    public class CollectionAllSatisfyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyAssertion(.<.<TItem>> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyAssertion(.<TCollection> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyHelper<TItem>
+    public class CollectionAllSatisfyHelper<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyHelper(.<.<TItem>> context) { }
-        public .<TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
-        public .<TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
+        public CollectionAllSatisfyHelper(.<TCollection> context) { }
+        public .<TCollection, TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TCollection, TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
     }
-    public class CollectionAllSatisfyMappedAssertion<TItem, TMapped> : .<TItem>
+    public class CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyMappedAssertion(.<.<TItem>> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyMappedAssertion(.<TCollection> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Any")]
-    public class CollectionAnyAssertion<TItem> : .<TItem>
+    public class CollectionAnyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAnyAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAnyAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public abstract class CollectionComparerBasedAssertion<TItem> : .<TItem>
+    public abstract class CollectionComparerBasedAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        protected CollectionComparerBasedAssertion(.<.<TItem>> context) { }
+        protected CollectionComparerBasedAssertion(.<TCollection> context) { }
         protected .<TItem> GetComparer() { }
         protected bool HasCustomComparer() { }
         protected void SetComparer(.<TItem> comparer) { }
     }
     [.("Contains")]
-    public class CollectionContainsAssertion<TItem> : .<TItem>
+    public class CollectionContainsAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Contains")]
-    public class CollectionContainsPredicateAssertion<TItem> : .<TItem>
+    public class CollectionContainsPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsPredicateAssertion(.<TCollection> context, <TItem, bool> predicate) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
     [.("HasCount")]
-    public class CollectionCountAssertion<TItem> : .<TItem>
+    public class CollectionCountAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionCountAssertion(.<.<TItem>> context, int expectedCount) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionCountAssertion(.<TCollection> context, int expectedCount) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionCountValueAssertion<TItem> : .<int>
+    public class CollectionCountValueAssertion<TCollection, TItem> : .<int>
+        where TCollection : .<TItem>
     {
-        public CollectionCountValueAssertion(.<.<TItem>> collectionContext, <TItem, bool>? predicate) { }
+        public CollectionCountValueAssertion(.<TCollection> collectionContext, <TItem, bool>? predicate) { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainPredicateAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsEmpty")]
-    public class CollectionIsEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInDescendingOrder")]
-    public class CollectionIsInDescendingOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInDescendingOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInDescendingOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInDescendingOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInOrder")]
-    public class CollectionIsInOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsNotEmpty")]
-    public class CollectionIsNotEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsNotEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsNotEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsNotEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByDescendingAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByDescendingAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByDescendingAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
@@ -905,10 +923,11 @@ namespace .Conditions
         protected override string GetExpectation() { }
     }
     [.("HasSingleItem")]
-    public class HasSingleItemAssertion<TItem> : .<TItem>
+    public class HasSingleItemAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public HasSingleItemAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public HasSingleItemAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
@@ -977,14 +996,15 @@ namespace .Conditions
     [.("Collection equivalency uses structural comparison for complex objects, which requ" +
         "ires reflection and is not compatible with AOT")]
     [.("IsEquivalentTo")]
-    public class IsEquivalentToAssertion<TItem> : .<TItem>
+    public class IsEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, . ordering = 0) { }
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
         [.("AOT", "IL3050", Justification="Collection equivalency uses structural comparison which requires reflection")]
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     [.("IsIn")]
     public class IsInAssertion<TValue> : .<TValue, TValue>
@@ -1082,13 +1102,14 @@ namespace .Conditions
     [.("Collection equivalency uses structural comparison for complex objects, which requ" +
         "ires reflection and is not compatible with AOT")]
     [.("IsNotEquivalentTo")]
-    public class NotEquivalentToAssertion<TItem> : .<TItem>
+    public class NotEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public NotEquivalentToAssertion(.<.<TItem>> context, .<TItem> notExpected, . ordering = 0) { }
+        public NotEquivalentToAssertion(.<TCollection> context, .<TItem> notExpected, . ordering = 0) { }
         [.("AOT", "IL3050", Justification="Collection equivalency uses structural comparison which requires reflection")]
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     public class NotNullAssertion<TValue> : .<TValue>
     {
@@ -1525,18 +1546,19 @@ namespace .
 }
 namespace .
 {
-    public class CountWrapper<TItem> : ., .<.<TItem>>
+    public class CountWrapper<TCollection, TItem> : ., .<TCollection>
+        where TCollection : .<TItem>
     {
-        public CountWrapper(.<.<TItem>> context) { }
+        public CountWrapper(.<TCollection> context) { }
         public .<int> Between(int minimum, int maximum, [.("minimum")] string? minExpression = null, [.("maximum")] string? maxExpression = null) { }
-        public .<TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<int> GreaterThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> GreaterThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> NotEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> Positive() { }
-        public .<TItem> Zero() { }
+        public .<TCollection, TItem> Zero() { }
     }
     public class LengthWrapper : ., .<string>
     {
@@ -1598,8 +1620,10 @@ namespace .Core
         And = 1,
         Or = 2,
     }
-    public class CollectionAndContinuation<TItem> : .<TItem> { }
-    public class CollectionOrContinuation<TItem> : .<TItem> { }
+    public class CollectionAndContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
+    public class CollectionOrContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
     public class DictionaryAndContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue> { }
     public class DictionaryOrContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
@@ -2027,47 +2051,58 @@ namespace .Extensions
     }
     public static class CollectionAllAssertionExtensions
     {
-        public static .<TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> All<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionAnyAssertionExtensions
     {
-        public static .<TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> Any<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsPredicateAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionCountAssertionExtensions
     {
-        public static .<TItem> HasCount<TItem>(this .<.<TItem>> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null) { }
+        public static .<TCollection, TItem> HasCount<TCollection, TItem>(this .<TCollection> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainPredicateAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsEmptyAssertionExtensions
     {
-        public static .<TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInDescendingOrderAssertionExtensions
     {
-        public static .<TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInDescendingOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInOrderAssertionExtensions
     {
-        public static .<TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsNotEmptyAssertionExtensions
     {
-        public static .<TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsNotEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CultureInfoAssertionExtensions
     {
@@ -2755,7 +2790,8 @@ namespace .Extensions
     }
     public static class HasSingleItemAssertionExtensions
     {
-        public static .<TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> HasSingleItem<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class HttpStatusCodeAssertionExtensions
     {
@@ -2915,10 +2951,12 @@ namespace .Extensions
     {
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class IsInAssertionExtensions
     {
@@ -2980,7 +3018,8 @@ namespace .Extensions
     {
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsNotEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsNotEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class NotSameReferenceAssertionExtensions
     {
@@ -3766,36 +3805,37 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class CollectionAssertionBase<TItem> : .<.<TItem>>, ., .<.<TItem>>
-    {
-        protected CollectionAssertionBase(.<.<TItem>> context) { }
-        public new .<TItem> And { get; }
-        public new .<TItem> Or { get; }
-        public .<TItem> All() { }
-        public .<TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
-        public .<TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Count() { }
-        public .<TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
-        protected override string GetExpectation() { }
-        public ..CountWrapper<TItem> HasCount() { }
-        public .<TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<TItem> HasSingleItem() { }
-        public .<TItem> IsEmpty() { }
-        public .<TItem> IsInDescendingOrder() { }
-        public .<TItem> IsInOrder() { }
-        public .<TItem> IsNotEmpty() { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
-    }
-    public class CollectionAssertion<TItem> : .<TItem>
+    public abstract class CollectionAssertionBase<TCollection, TItem> : .<TCollection>, ., .<TCollection>
+        where TCollection : .<TItem>
+    {
+        protected CollectionAssertionBase(.<TCollection> context) { }
+        public new .<TCollection, TItem> And { get; }
+        public new .<TCollection, TItem> Or { get; }
+        public .<TCollection, TItem> All() { }
+        public .<TCollection, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Count() { }
+        public .<TCollection, TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        protected override string GetExpectation() { }
+        public ..CountWrapper<TCollection, TItem> HasCount() { }
+        public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> HasSingleItem() { }
+        public .<TCollection, TItem> IsEmpty() { }
+        public .<TCollection, TItem> IsInDescendingOrder() { }
+        public .<TCollection, TItem> IsInOrder() { }
+        public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
+    }
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
     }
@@ -3808,25 +3848,16 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary>, ., .<TDictionary>
+    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary, .<TKey, TValue>>
         where TDictionary : .<TKey, TValue>
     {
         protected DictionaryAssertionBase(.<TDictionary> context) { }
         public new .<TDictionary, TKey, TValue> And { get; }
         public new .<TDictionary, TKey, TValue> Or { get; }
-        public .<.<TKey, TValue>> All() { }
-        public .<.<TKey, TValue>> All(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Any(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(.<TKey, TValue> expected, [.("expected")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         protected override string GetExpectation() { }
-        public ..CountWrapper<.<TKey, TValue>> HasCount() { }
-        public .<.<TKey, TValue>> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<.<TKey, TValue>> IsEmpty() { }
-        public .<.<TKey, TValue>> IsNotEmpty() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
     {
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index 98f26c15ce..d0f8e8b482 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -367,122 +367,140 @@ namespace .Conditions
     [.<char>("IsWhiteSpace", ExpectationMessage="be whitespace")]
     public static class CharAssertionExtensions { }
     [.("All")]
-    public class CollectionAllAssertion<TItem> : .<TItem>
+    public class CollectionAllAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyAssertion<TItem> : .<TItem>
+    public class CollectionAllSatisfyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyAssertion(.<.<TItem>> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyAssertion(.<TCollection> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyHelper<TItem>
+    public class CollectionAllSatisfyHelper<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyHelper(.<.<TItem>> context) { }
-        public .<TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
-        public .<TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
+        public CollectionAllSatisfyHelper(.<TCollection> context) { }
+        public .<TCollection, TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TCollection, TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
     }
-    public class CollectionAllSatisfyMappedAssertion<TItem, TMapped> : .<TItem>
+    public class CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyMappedAssertion(.<.<TItem>> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyMappedAssertion(.<TCollection> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Any")]
-    public class CollectionAnyAssertion<TItem> : .<TItem>
+    public class CollectionAnyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAnyAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAnyAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public abstract class CollectionComparerBasedAssertion<TItem> : .<TItem>
+    public abstract class CollectionComparerBasedAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        protected CollectionComparerBasedAssertion(.<.<TItem>> context) { }
+        protected CollectionComparerBasedAssertion(.<TCollection> context) { }
         protected .<TItem> GetComparer() { }
         protected bool HasCustomComparer() { }
         protected void SetComparer(.<TItem> comparer) { }
     }
     [.("Contains")]
-    public class CollectionContainsAssertion<TItem> : .<TItem>
+    public class CollectionContainsAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Contains")]
-    public class CollectionContainsPredicateAssertion<TItem> : .<TItem>
+    public class CollectionContainsPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsPredicateAssertion(.<TCollection> context, <TItem, bool> predicate) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
     [.("HasCount")]
-    public class CollectionCountAssertion<TItem> : .<TItem>
+    public class CollectionCountAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionCountAssertion(.<.<TItem>> context, int expectedCount) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionCountAssertion(.<TCollection> context, int expectedCount) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionCountValueAssertion<TItem> : .<int>
+    public class CollectionCountValueAssertion<TCollection, TItem> : .<int>
+        where TCollection : .<TItem>
     {
-        public CollectionCountValueAssertion(.<.<TItem>> collectionContext, <TItem, bool>? predicate) { }
+        public CollectionCountValueAssertion(.<TCollection> collectionContext, <TItem, bool>? predicate) { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainPredicateAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsEmpty")]
-    public class CollectionIsEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInDescendingOrder")]
-    public class CollectionIsInDescendingOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInDescendingOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInDescendingOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInDescendingOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInOrder")]
-    public class CollectionIsInOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsNotEmpty")]
-    public class CollectionIsNotEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsNotEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsNotEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsNotEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByDescendingAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByDescendingAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByDescendingAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
@@ -908,10 +926,11 @@ namespace .Conditions
         protected override string GetExpectation() { }
     }
     [.("HasSingleItem")]
-    public class HasSingleItemAssertion<TItem> : .<TItem>
+    public class HasSingleItemAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public HasSingleItemAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public HasSingleItemAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
@@ -980,14 +999,15 @@ namespace .Conditions
     [.("Collection equivalency uses structural comparison for complex objects, which requ" +
         "ires reflection and is not compatible with AOT")]
     [.("IsEquivalentTo")]
-    public class IsEquivalentToAssertion<TItem> : .<TItem>
+    public class IsEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, . ordering = 0) { }
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
         [.("AOT", "IL3050", Justification="Collection equivalency uses structural comparison which requires reflection")]
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     [.("IsIn")]
     public class IsInAssertion<TValue> : .<TValue, TValue>
@@ -1085,13 +1105,14 @@ namespace .Conditions
     [.("Collection equivalency uses structural comparison for complex objects, which requ" +
         "ires reflection and is not compatible with AOT")]
     [.("IsNotEquivalentTo")]
-    public class NotEquivalentToAssertion<TItem> : .<TItem>
+    public class NotEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public NotEquivalentToAssertion(.<.<TItem>> context, .<TItem> notExpected, . ordering = 0) { }
+        public NotEquivalentToAssertion(.<TCollection> context, .<TItem> notExpected, . ordering = 0) { }
         [.("AOT", "IL3050", Justification="Collection equivalency uses structural comparison which requires reflection")]
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     public class NotNullAssertion<TValue> : .<TValue>
     {
@@ -1528,18 +1549,19 @@ namespace .
 }
 namespace .
 {
-    public class CountWrapper<TItem> : ., .<.<TItem>>
+    public class CountWrapper<TCollection, TItem> : ., .<TCollection>
+        where TCollection : .<TItem>
     {
-        public CountWrapper(.<.<TItem>> context) { }
+        public CountWrapper(.<TCollection> context) { }
         public .<int> Between(int minimum, int maximum, [.("minimum")] string? minExpression = null, [.("maximum")] string? maxExpression = null) { }
-        public .<TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<int> GreaterThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> GreaterThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> NotEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> Positive() { }
-        public .<TItem> Zero() { }
+        public .<TCollection, TItem> Zero() { }
     }
     public class LengthWrapper : ., .<string>
     {
@@ -1601,8 +1623,10 @@ namespace .Core
         And = 1,
         Or = 2,
     }
-    public class CollectionAndContinuation<TItem> : .<TItem> { }
-    public class CollectionOrContinuation<TItem> : .<TItem> { }
+    public class CollectionAndContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
+    public class CollectionOrContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
     public class DictionaryAndContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue> { }
     public class DictionaryOrContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
@@ -2030,47 +2054,58 @@ namespace .Extensions
     }
     public static class CollectionAllAssertionExtensions
     {
-        public static .<TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> All<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionAnyAssertionExtensions
     {
-        public static .<TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> Any<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsPredicateAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionCountAssertionExtensions
     {
-        public static .<TItem> HasCount<TItem>(this .<.<TItem>> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null) { }
+        public static .<TCollection, TItem> HasCount<TCollection, TItem>(this .<TCollection> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainPredicateAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsEmptyAssertionExtensions
     {
-        public static .<TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInDescendingOrderAssertionExtensions
     {
-        public static .<TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInDescendingOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInOrderAssertionExtensions
     {
-        public static .<TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsNotEmptyAssertionExtensions
     {
-        public static .<TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsNotEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CultureInfoAssertionExtensions
     {
@@ -2763,7 +2798,8 @@ namespace .Extensions
     }
     public static class HasSingleItemAssertionExtensions
     {
-        public static .<TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> HasSingleItem<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class HttpStatusCodeAssertionExtensions
     {
@@ -2924,10 +2960,12 @@ namespace .Extensions
     {
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class IsInAssertionExtensions
     {
@@ -2990,7 +3028,8 @@ namespace .Extensions
     {
         [.("Collection equivalency uses structural comparison for complex objects, which requ" +
             "ires reflection and is not compatible with AOT")]
-        public static .<TItem> IsNotEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsNotEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class NotSameReferenceAssertionExtensions
     {
@@ -3779,36 +3818,37 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class CollectionAssertionBase<TItem> : .<.<TItem>>, ., .<.<TItem>>
-    {
-        protected CollectionAssertionBase(.<.<TItem>> context) { }
-        public new .<TItem> And { get; }
-        public new .<TItem> Or { get; }
-        public .<TItem> All() { }
-        public .<TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
-        public .<TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Count() { }
-        public .<TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
-        protected override string GetExpectation() { }
-        public ..CountWrapper<TItem> HasCount() { }
-        public .<TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<TItem> HasSingleItem() { }
-        public .<TItem> IsEmpty() { }
-        public .<TItem> IsInDescendingOrder() { }
-        public .<TItem> IsInOrder() { }
-        public .<TItem> IsNotEmpty() { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
-    }
-    public class CollectionAssertion<TItem> : .<TItem>
+    public abstract class CollectionAssertionBase<TCollection, TItem> : .<TCollection>, ., .<TCollection>
+        where TCollection : .<TItem>
+    {
+        protected CollectionAssertionBase(.<TCollection> context) { }
+        public new .<TCollection, TItem> And { get; }
+        public new .<TCollection, TItem> Or { get; }
+        public .<TCollection, TItem> All() { }
+        public .<TCollection, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Count() { }
+        public .<TCollection, TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        protected override string GetExpectation() { }
+        public ..CountWrapper<TCollection, TItem> HasCount() { }
+        public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> HasSingleItem() { }
+        public .<TCollection, TItem> IsEmpty() { }
+        public .<TCollection, TItem> IsInDescendingOrder() { }
+        public .<TCollection, TItem> IsInOrder() { }
+        public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
+    }
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
     }
@@ -3821,25 +3861,16 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary>, ., .<TDictionary>
+    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary, .<TKey, TValue>>
         where TDictionary : .<TKey, TValue>
     {
         protected DictionaryAssertionBase(.<TDictionary> context) { }
         public new .<TDictionary, TKey, TValue> And { get; }
         public new .<TDictionary, TKey, TValue> Or { get; }
-        public .<.<TKey, TValue>> All() { }
-        public .<.<TKey, TValue>> All(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Any(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(.<TKey, TValue> expected, [.("expected")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         protected override string GetExpectation() { }
-        public ..CountWrapper<.<TKey, TValue>> HasCount() { }
-        public .<.<TKey, TValue>> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<.<TKey, TValue>> IsEmpty() { }
-        public .<.<TKey, TValue>> IsNotEmpty() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
     {
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
index 96fa125ba7..6f0410a106 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
@@ -362,122 +362,140 @@ namespace .Conditions
     [.<char>("IsWhiteSpace", ExpectationMessage="be whitespace")]
     public static class CharAssertionExtensions { }
     [.("All")]
-    public class CollectionAllAssertion<TItem> : .<TItem>
+    public class CollectionAllAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyAssertion<TItem> : .<TItem>
+    public class CollectionAllSatisfyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyAssertion(.<.<TItem>> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyAssertion(.<TCollection> context, <.<TItem>, .<TItem>?> assertion, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionAllSatisfyHelper<TItem>
+    public class CollectionAllSatisfyHelper<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyHelper(.<.<TItem>> context) { }
-        public .<TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
-        public .<TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
+        public CollectionAllSatisfyHelper(.<TCollection> context) { }
+        public .<TCollection, TItem> Satisfy(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TCollection, TItem, TMapped> Satisfy<TMapped>(<TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, [.("mapper")] string? mapperExpression = null, [.("assertion")] string? assertionExpression = null) { }
     }
-    public class CollectionAllSatisfyMappedAssertion<TItem, TMapped> : .<TItem>
+    public class CollectionAllSatisfyMappedAssertion<TCollection, TItem, TMapped> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAllSatisfyMappedAssertion(.<.<TItem>> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAllSatisfyMappedAssertion(.<TCollection> context, <TItem, TMapped> mapper, <.<TMapped>, .<TMapped>?> assertion, string mapperDescription, string assertionDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Any")]
-    public class CollectionAnyAssertion<TItem> : .<TItem>
+    public class CollectionAnyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionAnyAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionAnyAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public abstract class CollectionComparerBasedAssertion<TItem> : .<TItem>
+    public abstract class CollectionComparerBasedAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        protected CollectionComparerBasedAssertion(.<.<TItem>> context) { }
+        protected CollectionComparerBasedAssertion(.<TCollection> context) { }
         protected .<TItem> GetComparer() { }
         protected bool HasCustomComparer() { }
         protected void SetComparer(.<TItem> comparer) { }
     }
     [.("Contains")]
-    public class CollectionContainsAssertion<TItem> : .<TItem>
+    public class CollectionContainsAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("Contains")]
-    public class CollectionContainsPredicateAssertion<TItem> : .<TItem>
+    public class CollectionContainsPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionContainsPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionContainsPredicateAssertion(.<TCollection> context, <TItem, bool> predicate) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
     [.("HasCount")]
-    public class CollectionCountAssertion<TItem> : .<TItem>
+    public class CollectionCountAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionCountAssertion(.<.<TItem>> context, int expectedCount) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionCountAssertion(.<TCollection> context, int expectedCount) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionCountValueAssertion<TItem> : .<int>
+    public class CollectionCountValueAssertion<TCollection, TItem> : .<int>
+        where TCollection : .<TItem>
     {
-        public CollectionCountValueAssertion(.<.<TItem>> collectionContext, <TItem, bool>? predicate) { }
+        public CollectionCountValueAssertion(.<TCollection> collectionContext, <TItem, bool>? predicate) { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainAssertion(.<.<TItem>> context, TItem expected, .<TItem>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainAssertion(.<TCollection> context, TItem expected, .<TItem>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("DoesNotContain")]
-    public class CollectionDoesNotContainPredicateAssertion<TItem> : .<TItem>
+    public class CollectionDoesNotContainPredicateAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionDoesNotContainPredicateAssertion(.<.<TItem>> context, <TItem, bool> predicate, string predicateDescription) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionDoesNotContainPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsEmpty")]
-    public class CollectionIsEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInDescendingOrder")]
-    public class CollectionIsInDescendingOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInDescendingOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInDescendingOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInDescendingOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsInOrder")]
-    public class CollectionIsInOrderAssertion<TItem> : .<TItem>
+    public class CollectionIsInOrderAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsInOrderAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsInOrderAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     [.("IsNotEmpty")]
-    public class CollectionIsNotEmptyAssertion<TItem> : .<TItem>
+    public class CollectionIsNotEmptyAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsNotEmptyAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsNotEmptyAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class CollectionIsOrderedByDescendingAssertion<TItem, TKey> : .<TItem>
+    public class CollectionIsOrderedByDescendingAssertion<TCollection, TItem, TKey> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public CollectionIsOrderedByDescendingAssertion(.<.<TItem>> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public CollectionIsOrderedByDescendingAssertion(.<TCollection> context, <TItem, TKey> keySelector, .<TKey>? comparer = null) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
@@ -864,10 +882,11 @@ namespace .Conditions
         protected override string GetExpectation() { }
     }
     [.("HasSingleItem")]
-    public class HasSingleItemAssertion<TItem> : .<TItem>
+    public class HasSingleItemAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public HasSingleItemAssertion(.<.<TItem>> context) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public HasSingleItemAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
     }
@@ -931,13 +950,14 @@ namespace .Conditions
         public .<TValue> Using(.<TValue> comparer) { }
     }
     [.("IsEquivalentTo")]
-    public class IsEquivalentToAssertion<TItem> : .<TItem>
+    public class IsEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, . ordering = 0) { }
-        public IsEquivalentToAssertion(.<.<TItem>> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, . ordering = 0) { }
+        public IsEquivalentToAssertion(.<TCollection> context, .<TItem> expected, .<TItem> comparer, . ordering = 0) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     [.("IsIn")]
     public class IsInAssertion<TValue> : .<TValue, TValue>
@@ -1031,12 +1051,13 @@ namespace .Conditions
         public .<TValue> IgnoringType<TIgnore>() { }
     }
     [.("IsNotEquivalentTo")]
-    public class NotEquivalentToAssertion<TItem> : .<TItem>
+    public class NotEquivalentToAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
     {
-        public NotEquivalentToAssertion(.<.<TItem>> context, .<TItem> notExpected, . ordering = 0) { }
-        protected override .<.> CheckAsync(.<.<TItem>> metadata) { }
+        public NotEquivalentToAssertion(.<TCollection> context, .<TItem> notExpected, . ordering = 0) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
-        public .<TItem> Using(.<TItem> comparer) { }
+        public .<TCollection, TItem> Using(.<TItem> comparer) { }
     }
     public class NotNullAssertion<TValue> : .<TValue>
     {
@@ -1429,18 +1450,19 @@ namespace .
 }
 namespace .
 {
-    public class CountWrapper<TItem> : ., .<.<TItem>>
+    public class CountWrapper<TCollection, TItem> : ., .<TCollection>
+        where TCollection : .<TItem>
     {
-        public CountWrapper(.<.<TItem>> context) { }
+        public CountWrapper(.<TCollection> context) { }
         public .<int> Between(int minimum, int maximum, [.("minimum")] string? minExpression = null, [.("maximum")] string? maxExpression = null) { }
-        public .<TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> EqualTo(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<int> GreaterThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> GreaterThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThan(int expected, [.("expected")] string? expression = null) { }
         public .<int> LessThanOrEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> NotEqualTo(int expected, [.("expected")] string? expression = null) { }
         public .<int> Positive() { }
-        public .<TItem> Zero() { }
+        public .<TCollection, TItem> Zero() { }
     }
     public class LengthWrapper : ., .<string>
     {
@@ -1502,8 +1524,10 @@ namespace .Core
         And = 1,
         Or = 2,
     }
-    public class CollectionAndContinuation<TItem> : .<TItem> { }
-    public class CollectionOrContinuation<TItem> : .<TItem> { }
+    public class CollectionAndContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
+    public class CollectionOrContinuation<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem> { }
     public class DictionaryAndContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue> { }
     public class DictionaryOrContinuation<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
@@ -1909,47 +1933,58 @@ namespace .Extensions
     }
     public static class CollectionAllAssertionExtensions
     {
-        public static .<TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> All<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionAnyAssertionExtensions
     {
-        public static .<TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> Any<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionContainsPredicateAssertionExtensions
     {
-        public static .<TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null) { }
+        public static .<TCollection, TItem> Contains<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, [.("predicate")] string? predicateExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionCountAssertionExtensions
     {
-        public static .<TItem> HasCount<TItem>(this .<.<TItem>> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null) { }
+        public static .<TCollection, TItem> HasCount<TCollection, TItem>(this .<TCollection> source, int expectedCount, [.("expectedCount")] string? expectedCountExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, TItem expected, .<TItem>? comparer = null, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionDoesNotContainPredicateAssertionExtensions
     {
-        public static .<TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null) { }
+        public static .<TCollection, TItem> DoesNotContain<TCollection, TItem>(this .<TCollection> source, <TItem, bool> predicate, string predicateDescription, [.("predicate")] string? predicateExpression = null, [.("predicateDescription")] string? predicateDescriptionExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsEmptyAssertionExtensions
     {
-        public static .<TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInDescendingOrderAssertionExtensions
     {
-        public static .<TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInDescendingOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsInOrderAssertionExtensions
     {
-        public static .<TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CollectionIsNotEmptyAssertionExtensions
     {
-        public static .<TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> IsNotEmpty<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class CultureInfoAssertionExtensions
     {
@@ -2560,7 +2595,8 @@ namespace .Extensions
     }
     public static class HasSingleItemAssertionExtensions
     {
-        public static .<TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TCollection, TItem> HasSingleItem<TCollection, TItem>(this .<TCollection> source)
+            where TCollection : .<TItem> { }
     }
     public static class HttpStatusCodeAssertionExtensions
     {
@@ -2705,8 +2741,10 @@ namespace .Extensions
     }
     public static class IsEquivalentToAssertionExtensions
     {
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
-        public static .<TItem> IsEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
+        public static .<TCollection, TItem> IsEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> expected, .<TItem> comparer, . ordering = 0, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class IsInAssertionExtensions
     {
@@ -2762,7 +2800,8 @@ namespace .Extensions
     }
     public static class NotEquivalentToAssertionExtensions
     {
-        public static .<TItem> IsNotEquivalentTo<TItem>(this .<.<TItem>> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null) { }
+        public static .<TCollection, TItem> IsNotEquivalentTo<TCollection, TItem>(this .<TCollection> source, .<TItem> notExpected, . ordering = 0, [.("notExpected")] string? notExpectedExpression = null, [.("ordering")] string? orderingExpression = null)
+            where TCollection : .<TItem> { }
     }
     public static class NotSameReferenceAssertionExtensions
     {
@@ -3436,36 +3475,37 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class CollectionAssertionBase<TItem> : .<.<TItem>>, ., .<.<TItem>>
-    {
-        protected CollectionAssertionBase(.<.<TItem>> context) { }
-        public new .<TItem> And { get; }
-        public new .<TItem> Or { get; }
-        public .<TItem> All() { }
-        public .<TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
-        public .<TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> Count() { }
-        public .<TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
-        protected override string GetExpectation() { }
-        public ..CountWrapper<TItem> HasCount() { }
-        public .<TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<TItem> HasSingleItem() { }
-        public .<TItem> IsEmpty() { }
-        public .<TItem> IsInDescendingOrder() { }
-        public .<TItem> IsInOrder() { }
-        public .<TItem> IsNotEmpty() { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
-        public .<TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
-        public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
-    }
-    public class CollectionAssertion<TItem> : .<TItem>
+    public abstract class CollectionAssertionBase<TCollection, TItem> : .<TCollection>, ., .<TCollection>
+        where TCollection : .<TItem>
+    {
+        protected CollectionAssertionBase(.<TCollection> context) { }
+        public new .<TCollection, TItem> And { get; }
+        public new .<TCollection, TItem> Or { get; }
+        public .<TCollection, TItem> All() { }
+        public .<TCollection, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> Count() { }
+        public .<TCollection, TItem> Count(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        protected override string GetExpectation() { }
+        public ..CountWrapper<TCollection, TItem> HasCount() { }
+        public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
+        public .<TCollection, TItem> HasSingleItem() { }
+        public .<TCollection, TItem> IsEmpty() { }
+        public .<TCollection, TItem> IsInDescendingOrder() { }
+        public .<TCollection, TItem> IsInOrder() { }
+        public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
+    }
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
     }
@@ -3478,25 +3518,16 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary>, ., .<TDictionary>
+    public abstract class DictionaryAssertionBase<TDictionary, TKey, TValue> : .<TDictionary, .<TKey, TValue>>
         where TDictionary : .<TKey, TValue>
     {
         protected DictionaryAssertionBase(.<TDictionary> context) { }
         public new .<TDictionary, TKey, TValue> And { get; }
         public new .<TDictionary, TKey, TValue> Or { get; }
-        public .<.<TKey, TValue>> All() { }
-        public .<.<TKey, TValue>> All(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Any(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(.<TKey, TValue> expected, [.("expected")] string? expression = null) { }
-        public .<.<TKey, TValue>> Contains(<.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> ContainsKey(TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         protected override string GetExpectation() { }
-        public ..CountWrapper<.<TKey, TValue>> HasCount() { }
-        public .<.<TKey, TValue>> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
-        public .<.<TKey, TValue>> IsEmpty() { }
-        public .<.<TKey, TValue>> IsNotEmpty() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
     {