diff --git a/TUnit.Assertions.Tests/ListAssertionTests.cs b/TUnit.Assertions.Tests/ListAssertionTests.cs
index 7272cbed486..9ea13dae50e 100644
--- a/TUnit.Assertions.Tests/ListAssertionTests.cs
+++ b/TUnit.Assertions.Tests/ListAssertionTests.cs
@@ -203,6 +203,105 @@ public async Task Test_List_HasSingleItem()
         await Assert.That(list).HasSingleItem();
     }
 
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Allows_Chaining()
+    {
+        IList<int> list = new List<int> { 42 };
+
+        await Assert.That(list).HasSingleItem().Item.IsEqualTo(42);
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Preserves_Preceding_Chain()
+    {
+        IList<int> list = new List<int> { 42 };
+
+        await Assert.That(list).IsNotEmpty().And.HasSingleItem().Item.IsEqualTo(42);
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Does_Not_Reenumerate()
+    {
+        var enumerationCount = 0;
+
+        IEnumerable<int> GetItems()
+        {
+            enumerationCount++;
+            yield return 42;
+        }
+
+        await Assert.That(GetItems()).HasSingleItem().Item.IsEqualTo(42);
+        await Assert.That(enumerationCount).IsEqualTo(1);
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Preserves_Collection_Shape()
+    {
+        IList<List<int>> list = [new List<int> { 1, 2, 3 }];
+
+        await Assert.That(list).HasSingleItem().Item.Count().IsEqualTo(3);
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Fails_Before_Item_Assertion()
+    {
+        IList<int> list = [];
+
+        var action = async () => await Assert.That(list).HasSingleItem().Item.IsEqualTo(0);
+
+        await Assert.That(action).ThrowsException();
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Rejects_Preceding_Or_Chain()
+    {
+        var action = async () => await Assert.That(Array.Empty<int>())
+            .IsEmpty().Or.HasSingleItem().Item.IsEqualTo(0);
+
+        await Assert.That(action).Throws<MixedAndOrAssertionsException>();
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Or_Cannot_Bypass_Parent_Assertion()
+    {
+        var action = async () => await Assert.That(Array.Empty<int>())
+            .HasSingleItem().Item.IsEqualTo(1).Or.IsEqualTo(0);
+
+        await Assert.That(action).ThrowsException();
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Preserves_Parent_Through_Mappings()
+    {
+        await Assert.That(new[] { "value" }).HasSingleItem().Item.Length().IsEqualTo(5);
+
+        var action = async () => await Assert.That(Array.Empty<string>())
+            .HasSingleItem().Item.Length().IsEqualTo(0);
+
+        await Assert.That(action).ThrowsException();
+    }
+
+    [Test]
+    public async Task Test_List_HasSingleItem_Item_Is_Not_Evaluated_After_Failure_In_Assert_Multiple()
+    {
+        var itemAssertionEvaluated = false;
+
+        var action = async () =>
+        {
+            using (Assert.Multiple())
+            {
+                await Assert.That(Array.Empty<int>()).HasSingleItem().Item.Satisfies(_ =>
+                {
+                    itemAssertionEvaluated = true;
+                    return true;
+                });
+            }
+        };
+
+        await Assert.That(action).ThrowsException();
+        await Assert.That(itemAssertionEvaluated).IsFalse();
+    }
+
     [Test]
     public async Task Test_List_HasSingleItem_WithPredicate()
     {
@@ -211,6 +310,14 @@ public async Task Test_List_HasSingleItem_WithPredicate()
         await Assert.That(item).IsEqualTo(3);
     }
 
+    [Test]
+    public async Task Test_List_HasSingleItem_WithPredicate_Item_Allows_Chaining()
+    {
+        IList<int> list = new List<int> { 1, 2, 3, 4, 5 };
+
+        await Assert.That(list).HasSingleItem(x => x == 3).Item.IsEqualTo(3);
+    }
+
     [Test]
     public async Task Test_List_HasSingleItem_WithPredicate_Fails_WhenNoneMatch()
     {
diff --git a/TUnit.Assertions.Tests/MemoryAssertionTests.cs b/TUnit.Assertions.Tests/MemoryAssertionTests.cs
index de703c1341c..238f49e6e8a 100644
--- a/TUnit.Assertions.Tests/MemoryAssertionTests.cs
+++ b/TUnit.Assertions.Tests/MemoryAssertionTests.cs
@@ -55,6 +55,14 @@ public async Task Test_Memory_HasSingleItem()
         await Assert.That(memory).HasSingleItem();
     }
 
+    [Test]
+    public async Task Test_Memory_HasSingleItem_Item_Allows_Chaining()
+    {
+        Memory<int> memory = new[] { 42 };
+
+        await Assert.That(memory).HasSingleItem().Item.IsEqualTo(42);
+    }
+
     [Test]
     public async Task Test_Memory_All()
     {
diff --git a/TUnit.Assertions.Tests/ParseAssertionTests.cs b/TUnit.Assertions.Tests/ParseAssertionTests.cs
index bcc605df94e..3241dee12a0 100644
--- a/TUnit.Assertions.Tests/ParseAssertionTests.cs
+++ b/TUnit.Assertions.Tests/ParseAssertionTests.cs
@@ -161,8 +161,9 @@ await Assert.That(sut)
             }
         }).ThrowsException();
 
-        // Should have recorded the length assertion failure
+        // Both the pre-work failure and mapped assertion failure must be recorded.
         await Assert.That(exception.Message).Contains("length");
+        await Assert.That(exception.Message).Contains("456");
     }
 
     [Test]
diff --git a/TUnit.Assertions/Collections/MemoryAssertions.cs b/TUnit.Assertions/Collections/MemoryAssertions.cs
index 2c24d2c83e6..f88530eeffb 100644
--- a/TUnit.Assertions/Collections/MemoryAssertions.cs
+++ b/TUnit.Assertions/Collections/MemoryAssertions.cs
@@ -1,6 +1,7 @@
 #if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
 using TUnit.Assertions.Abstractions;
+using TUnit.Assertions.Conditions;
 using TUnit.Assertions.Conditions.Helpers;
 using TUnit.Assertions.Core;
 using TUnit.Assertions.Enums;
@@ -235,6 +236,7 @@ protected override string GetExpectation() =>
 public class MemoryHasSingleItemAssertion<TMemory, TItem> : MemoryAssertionBase<TMemory, TItem>
 {
     private readonly Func<TMemory, ICollectionAdapter<TItem>> _adapterFactory;
+    private TItem? _singleItem;
 
     public MemoryHasSingleItemAssertion(
         AssertionContext<TMemory> context,
@@ -259,10 +261,24 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TMemory>
         }
 
         var adapter = _adapterFactory(metadata.Value);
-        return Task.FromResult(CollectionChecks.CheckHasSingleItem(adapter));
+        return Task.FromResult(CollectionChecks.CheckHasSingleItem(adapter, out _singleItem));
     }
 
     protected override string GetExpectation() => "to have a single item";
+
+    /// <summary>
+    /// Drills into the single item, allowing assertions to be chained directly against it.
+    /// </summary>
+    public SingleItemSource<TItem> Item
+    {
+        get
+        {
+            ThrowIfMixingCombiner<Chaining.OrAssertion<TMemory>>();
+            Context.ExpressionBuilder.Append(".Item");
+            Context.SetPendingLink(InternalWrappedExecution ?? this, CombinerType.And);
+            return SingleItemSource<TItem>.Create(Context, _ => _singleItem);
+        }
+    }
 }
 
 /// <summary>
diff --git a/TUnit.Assertions/Conditions/CollectionAssertions.cs b/TUnit.Assertions/Conditions/CollectionAssertions.cs
index 78f0590971b..199f254866d 100644
--- a/TUnit.Assertions/Conditions/CollectionAssertions.cs
+++ b/TUnit.Assertions/Conditions/CollectionAssertions.cs
@@ -501,6 +501,20 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollecti
 
     protected override string GetExpectation() => "to have exactly one item";
 
+    /// <summary>
+    /// Drills into the single item, allowing assertions to be chained directly against it.
+    /// </summary>
+    public SingleItemSource<TItem> Item
+    {
+        get
+        {
+            ThrowIfMixingCombiner<Chaining.OrAssertion<TCollection>>();
+            Context.ExpressionBuilder.Append(".Item");
+            Context.SetPendingLink(InternalWrappedExecution ?? this, CombinerType.And);
+            return SingleItemSource<TItem>.Create(Context, _ => _singleItem);
+        }
+    }
+
     /// <summary>
     /// Enables await syntax that returns the single item.
     /// This allows both chaining (.And) and item capture (await).
@@ -560,6 +574,20 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollecti
 
     protected override string GetExpectation() => $"to have exactly one item matching {_predicateDescription}";
 
+    /// <summary>
+    /// Drills into the single matching item, allowing assertions to be chained directly against it.
+    /// </summary>
+    public SingleItemSource<TItem> Item
+    {
+        get
+        {
+            ThrowIfMixingCombiner<Chaining.OrAssertion<TCollection>>();
+            Context.ExpressionBuilder.Append(".Item");
+            Context.SetPendingLink(InternalWrappedExecution ?? this, CombinerType.And);
+            return SingleItemSource<TItem>.Create(Context, _ => _singleItem);
+        }
+    }
+
     /// <summary>
     /// Enables await syntax that returns the matching item.
     /// This allows both chaining (.And) and item capture (await).
diff --git a/TUnit.Assertions/Conditions/SingleItemSource.cs b/TUnit.Assertions/Conditions/SingleItemSource.cs
new file mode 100644
index 00000000000..f92cc9a1d5a
--- /dev/null
+++ b/TUnit.Assertions/Conditions/SingleItemSource.cs
@@ -0,0 +1,27 @@
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Sources;
+
+namespace TUnit.Assertions.Conditions;
+
+/// <summary>
+/// Assertion source for the item captured by a successful <c>HasSingleItem</c> assertion.
+/// </summary>
+/// <typeparam name="TItem">The collection item type.</typeparam>
+[global::TUnit.Assertions.Attributes.GenerateCollectionShapeAssertions]
+public sealed class SingleItemSource<TItem> : ValueAssertion<TItem>
+{
+    internal SingleItemSource(AssertionContext<TItem> context)
+        : base(context)
+    {
+    }
+
+    internal static SingleItemSource<TItem> Create<TValue>(
+        AssertionContext<TValue> context,
+        Func<TValue?, TItem?> mapper)
+    {
+        var itemContext = context.Map(mapper);
+        itemContext.PreservePendingPreWorkOnMap = true;
+        itemContext.SkipAssertionOnPreWorkFailure = true;
+        return new SingleItemSource<TItem>(itemContext);
+    }
+}
diff --git a/TUnit.Assertions/Core/Assertion.cs b/TUnit.Assertions/Core/Assertion.cs
index 4374a8f57b3..d5c6438d5b8 100644
--- a/TUnit.Assertions/Core/Assertion.cs
+++ b/TUnit.Assertions/Core/Assertion.cs
@@ -114,6 +114,11 @@ public Assertion<TValue> Because(string message)
     /// </summary>
     public virtual async Task<TValue?> AssertAsync()
     {
+        if (!await ExecutePendingPreWorkAsync())
+        {
+            return default;
+        }
+
         // If part of an And/Or chain, delegate to the wrapper
         if (_wrappedExecution != null)
         {
@@ -129,12 +134,9 @@ public Assertion<TValue> Because(string message)
     /// </summary>
     internal async Task<TValue?> ExecuteCoreAsync()
     {
-        // Execute any pending cross-type assertions first (e.g., string assertions before WhenParsedInto<int>)
-        if (Context.PendingPreWork != null)
+        if (!await ExecutePendingPreWorkAsync())
         {
-            var preWork = Context.PendingPreWork;
-            Context.PendingPreWork = null; // Clear BEFORE execution to prevent re-entry
-            await preWork();
+            return default;
         }
 
         // If this is an And/OrAssertion (composite), delegate to AssertAsync which has custom logic
@@ -155,6 +157,23 @@ public Assertion<TValue> Because(string message)
         return contextResult.Value;
     }
 
+    private async Task<bool> ExecutePendingPreWorkAsync()
+    {
+        if (Context.PendingPreWork is not { } preWork)
+        {
+            return true;
+        }
+
+        Context.PendingPreWork = null; // Clear before execution to prevent re-entry.
+        var currentScope = AssertionScope.GetCurrentAssertionScope();
+        var exceptionCountBefore = currentScope?.ExceptionCount ?? 0;
+        await preWork();
+
+        return !Context.SkipAssertionOnPreWorkFailure
+               || currentScope is null
+               || currentScope.ExceptionCount <= exceptionCountBefore;
+    }
+
     // Create EvaluationMetadata in a separate scope to avoid creating additional
     //  DateTimeOffset fields in the state machine
     private Task<AssertionResult> CreateMetadataAndCheckAsync(TValue? value, Exception? exception)
diff --git a/TUnit.Assertions/Core/AssertionContext.cs b/TUnit.Assertions/Core/AssertionContext.cs
index 80dd8099e84..b09e3d417e7 100644
--- a/TUnit.Assertions/Core/AssertionContext.cs
+++ b/TUnit.Assertions/Core/AssertionContext.cs
@@ -67,6 +67,17 @@ public AssertionContext<TNew> Map<TNew>(Func<EvaluationContext<TValue>, Evaluati
             newContext.PendingPreWork = async () => await pendingAssertion.ExecuteCoreAsync();
         }
 
+        if (PreservePendingPreWorkOnMap && PendingPreWork is { } preWork)
+        {
+            PendingPreWork = null;
+            var existing = newContext.PendingPreWork;
+            newContext.PendingPreWork = existing is null
+                ? preWork
+                : async () => { await preWork(); await existing(); };
+            newContext.PreservePendingPreWorkOnMap = true;
+            newContext.SkipAssertionOnPreWorkFailure = SkipAssertionOnPreWorkFailure;
+        }
+
         return newContext;
     }
 
@@ -160,6 +171,17 @@ public AssertionContext<TException> MapException<TException>() where TException
     /// </summary>
     internal Func<Task>? PendingPreWork { get; set; }
 
+    /// <summary>
+    /// Keeps pending pre-work attached while drill-in operations map through intermediate types.
+    /// </summary>
+    internal bool PreservePendingPreWorkOnMap { get; set; }
+
+    /// <summary>
+    /// Skips the mapped assertion when pending pre-work fails inside <see cref="Assert.Multiple"/>.
+    /// Used when the mapped value is only valid after the pre-work succeeds.
+    /// </summary>
+    internal bool SkipAssertionOnPreWorkFailure { get; set; }
+
     /// <summary>
     /// Sets the pending link state for the next assertion to consume.
     /// Called by AndContinuation/OrContinuation constructors.
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 6c79349f71c..aaef3f7c8ea 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
@@ -562,6 +562,7 @@ namespace .Collections
     public class MemoryHasSingleItemAssertion<TMemory, TItem> : .<TMemory, TItem>
     {
         public MemoryHasSingleItemAssertion(.<TMemory> context, <TMemory, .<TItem>> adapterFactory) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TMemory> metadata) { }
         protected override .<TItem> CreateAdapter(TMemory value) { }
         protected override string GetExpectation() { }
@@ -1329,6 +1330,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemAssertion(.<TCollection> context) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1338,6 +1340,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1988,6 +1991,7 @@ namespace .Conditions
     [.<float>("IsSubnormal", CustomName="IsNotSubnormal", ExpectationMessage="be subnormal", NegateLogic=true)]
     [.<float>("IsSubnormal", ExpectationMessage="be subnormal")]
     public static class SingleAssertionExtensions { }
+    public sealed class SingleItemSource<TItem> : .<TItem> { }
     [.(typeof(<!0>), "IsEmpty", CustomName="IsNotEmpty", ExpectationMessage="be empty", NegateLogic=true)]
     [.(typeof(<!0>), "IsEmpty", ExpectationMessage="be empty")]
     [.(typeof(<!0>), "IsEmpty", CustomName="IsNotEmpty", ExpectationMessage="be empty", NegateLogic=true)]
@@ -5608,6 +5612,481 @@ namespace .Extensions
         public static . IsPositiveInfinity(this .<float> source) { }
         public static . IsSubnormal(this .<float> source) { }
     }
+    public static class SingleItemSourceCollectionShapeAssertions
+    {
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Any<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> ContainsOnly<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        [.(-1)]
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        [.(-1)]
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        [.(-1)]
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtLeast<TItem>(this .<TItem[]> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtMost<TItem>(this .<TItem[]> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<TItem[], TItem> HasCountBetween<TItem>(this .<TItem[]> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInDescendingOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsNotEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? indexExpression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+    }
     public static class SpanAssertionExtensions { }
     public static class StreamAssertionExtensions
     {
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 7ea0eac6d10..6320c1887c2 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
@@ -545,6 +545,7 @@ namespace .Collections
     public class MemoryHasSingleItemAssertion<TMemory, TItem> : .<TMemory, TItem>
     {
         public MemoryHasSingleItemAssertion(.<TMemory> context, <TMemory, .<TItem>> adapterFactory) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TMemory> metadata) { }
         protected override .<TItem> CreateAdapter(TMemory value) { }
         protected override string GetExpectation() { }
@@ -1312,6 +1313,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemAssertion(.<TCollection> context) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1321,6 +1323,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1971,6 +1974,7 @@ namespace .Conditions
     [.<float>("IsSubnormal", CustomName="IsNotSubnormal", ExpectationMessage="be subnormal", NegateLogic=true)]
     [.<float>("IsSubnormal", ExpectationMessage="be subnormal")]
     public static class SingleAssertionExtensions { }
+    public sealed class SingleItemSource<TItem> : .<TItem> { }
     [.(typeof(<!0>), "IsEmpty", CustomName="IsNotEmpty", ExpectationMessage="be empty", NegateLogic=true)]
     [.(typeof(<!0>), "IsEmpty", ExpectationMessage="be empty")]
     [.(typeof(<!0>), "IsEmpty", CustomName="IsNotEmpty", ExpectationMessage="be empty", NegateLogic=true)]
@@ -5528,6 +5532,470 @@ namespace .Extensions
         public static . IsPositiveInfinity(this .<float> source) { }
         public static . IsSubnormal(this .<float> source) { }
     }
+    public static class SingleItemSourceCollectionShapeAssertions
+    {
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Any<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> ContainsOnly<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtLeast<TItem>(this .<TItem[]> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtMost<TItem>(this .<TItem[]> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<TItem[], TItem> HasCountBetween<TItem>(this .<TItem[]> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInDescendingOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsNotEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? indexExpression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+    }
     public static class SpanAssertionExtensions { }
     public static class StreamAssertionExtensions
     {
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 3329f0025d2..bad033c441a 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
@@ -562,6 +562,7 @@ namespace .Collections
     public class MemoryHasSingleItemAssertion<TMemory, TItem> : .<TMemory, TItem>
     {
         public MemoryHasSingleItemAssertion(.<TMemory> context, <TMemory, .<TItem>> adapterFactory) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TMemory> metadata) { }
         protected override .<TItem> CreateAdapter(TMemory value) { }
         protected override string GetExpectation() { }
@@ -1329,6 +1330,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemAssertion(.<TCollection> context) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1338,6 +1340,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1988,6 +1991,7 @@ namespace .Conditions
     [.<float>("IsSubnormal", CustomName="IsNotSubnormal", ExpectationMessage="be subnormal", NegateLogic=true)]
     [.<float>("IsSubnormal", ExpectationMessage="be subnormal")]
     public static class SingleAssertionExtensions { }
+    public sealed class SingleItemSource<TItem> : .<TItem> { }
     [.(typeof(<!0>), "IsEmpty", CustomName="IsNotEmpty", ExpectationMessage="be empty", NegateLogic=true)]
     [.(typeof(<!0>), "IsEmpty", ExpectationMessage="be empty")]
     [.(typeof(<!0>), "IsEmpty", CustomName="IsNotEmpty", ExpectationMessage="be empty", NegateLogic=true)]
@@ -5608,6 +5612,481 @@ namespace .Extensions
         public static . IsPositiveInfinity(this .<float> source) { }
         public static . IsSubnormal(this .<float> source) { }
     }
+    public static class SingleItemSourceCollectionShapeAssertions
+    {
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Any<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> ContainsOnly<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        [.(-1)]
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        [.(-1)]
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        [.(-1)]
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        [.(-1)]
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtLeast<TItem>(this .<TItem[]> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtMost<TItem>(this .<TItem[]> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<TItem[], TItem> HasCountBetween<TItem>(this .<TItem[]> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInDescendingOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsNotEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? indexExpression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+    }
     public static class SpanAssertionExtensions { }
     public static class StreamAssertionExtensions
     {
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 dedaac056ff..8e38d658c79 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
@@ -1151,6 +1151,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemAssertion(.<TCollection> context) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1160,6 +1161,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasSingleItemPredicateAssertion(.<TCollection> context, <TItem, bool> predicate, string predicateDescription) { }
+        public .<TItem> Item { get; }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         public .<TItem> GetAwaiter() { }
         protected override string GetExpectation() { }
@@ -1761,6 +1763,7 @@ namespace .Conditions
     [.<float>("IsPositiveInfinity", CustomName="IsNotPositiveInfinity", ExpectationMessage="be positive infinity", NegateLogic=true)]
     [.<float>("IsPositiveInfinity", ExpectationMessage="be positive infinity")]
     public static class SingleAssertionExtensions { }
+    public sealed class SingleItemSource<TItem> : .<TItem> { }
     [.("Contains")]
     public class StringContainsAssertion : .<string>
     {
@@ -4792,6 +4795,435 @@ namespace .Extensions
         public static . IsNotPositiveInfinity(this .<float> source) { }
         public static . IsPositiveInfinity(this .<float> source) { }
     }
+    public static class SingleItemSourceCollectionShapeAssertions
+    {
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> All<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> All<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> All<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllKeys<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AllValues<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Any<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Any<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Any<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyKey<TKey, TValue>(this .<.<TKey, TValue>> source, <TKey, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> AnyValue<TKey, TValue>(this .<.<TKey, TValue>> source, <TValue, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> Contains<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> Contains<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Contains<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, .<TKey>? comparer, [.("expectedKey")] string? keyExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsKeyWithValue<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, TValue expectedValue, [.("expectedKey")] string? keyExpression = null, [.("expectedValue")] string? valueExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ContainsOnly<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> ContainsOnly<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> ContainsOnly<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> ContainsValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Count<TItem>(this .<.<TItem>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<TItem>, .?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
+        public static .<TItem[], TItem> Count<TItem>(this .<TItem[]> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> Count<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<.<TKey, TValue>>, .?> itemAssertion, [.("itemAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> Count<TKey, TValue>(this .<.<TKey, TValue>> source, <.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, [.("expected")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> DoesNotContain<TItem>(this .<.<TItem>> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> DoesNotContain<TItem>(this .<TItem[]> source, TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, [.("expected")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> DoesNotContain<TKey, TValue>(this .<.<TKey, TValue>> source, .<TKey, TValue> expected, .<.<TKey, TValue>> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainKey<TKey, TValue>(this .<.<TKey, TValue>> source, TKey expectedKey, [.("expectedKey")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> DoesNotContainValue<TKey, TValue>(this .<.<TKey, TValue>> source, TValue expectedValue, [.("expectedValue")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> DoesNotOverlap<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> FirstItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtLeast<TItem>(this .<.<TItem>> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtLeast<TItem>(this .<TItem[]> source, int minCount, [.("minCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtLeast<TKey, TValue>(this .<.<TKey, TValue>> source, int minCount, [.("minCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasAtMost<TItem>(this .<.<TItem>> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<TItem[], TItem> HasAtMost<TItem>(this .<TItem[]> source, int maxCount, [.("maxCount")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasAtMost<TKey, TValue>(this .<.<TKey, TValue>> source, int maxCount, [.("maxCount")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TItem>, TItem> HasCountBetween<TItem>(this .<.<TItem>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<TItem[], TItem> HasCountBetween<TItem>(this .<TItem[]> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasCountBetween<TKey, TValue>(this .<.<TKey, TValue>> source, int min, int max, [.("min")] string? minExpression = null, [.("max")] string? maxExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> HasDistinctItems<TItem>(this .<.<TItem>> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem> HasDistinctItems<TItem>(this .<TItem[]> source, .<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> HasDistinctItems<TKey, TValue>(this .<.<TKey, TValue>> source, .<.<TKey, TValue>> comparer, [.("comparer")] string? comparerExpression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasItemAt<TItem>(this .<.<TItem>> source, int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TItem>, TItem> HasSingleItem<TItem>(this .<.<TItem>> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<TItem[], TItem> HasSingleItem<TItem>(this .<TItem[]> source, <TItem, bool> predicate, [.("predicate")] string? expression = null) { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> HasSingleItem<TKey, TValue>(this .<.<TKey, TValue>> source, <.<TKey, TValue>, bool> predicate, [.("predicate")] string? expression = null)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInDescendingOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInDescendingOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInDescendingOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsInOrder<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsInOrder<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, .<TKey, TValue>> IsInOrder<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> IsNotEmpty<TItem>(this .<.<TItem>> source) { }
+        public static .<TItem[], TItem> IsNotEmpty<TItem>(this .<TItem[]> source) { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TKey, TValue>, TKey, TValue> IsNotEmpty<TKey, TValue>(this .<.<TKey, TValue>> source)
+            where TKey :  notnull { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedBy<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedBy<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<.<TItem>> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<TItem[], TItem, TKey> IsOrderedByDescending<TItem, TKey>(this .<TItem[]> source, <TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsProperSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSubsetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> IsSupersetOf<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? indexExpression = null) { }
+        public static .<.<TItem>, TItem> ItemAt<TItem>(this .<.<TItem>> source, int index, [.("index")] string? expression = null) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> LastItem<TItem>(this .<.<TItem>> source) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> Overlaps<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+        public static .<.<TItem>, TItem> SetEquals<TItem>(this .<.<TItem>> source, .<TItem> other, [.("other")] string? expression = null) { }
+    }
     public static class StreamAssertionExtensions
     {
         public static . CanRead(this .<.Stream> source) { }
diff --git a/docs/docs/assertions/collections.md b/docs/docs/assertions/collections.md
index 5406ae9aeb0..b22be27ad95 100644
--- a/docs/docs/assertions/collections.md
+++ b/docs/docs/assertions/collections.md
@@ -239,6 +239,14 @@ public async Task Collection_Has_Single_Item()
 }
 ```
 
+Use `.Item` to continue assertions directly against the single item:
+
+```csharp
+await Assert.That(users)
+    .HasSingleItem()
+    .Item.Member(user => user.Name, name => name.IsEqualTo("Alice"));
+```
+
 ## Ordering Assertions
 
 ### IsInOrder