From 845294dee5766ec0c174eab031786c3adec7a731 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Sat, 28 Dec 2024 16:11:49 +0100
Subject: [PATCH] Hide "CountBy" in .NET 9+

This is squashed merge of PR #1092 that closes #1020.
---
 MoreLinq.Test/CountByTest.cs                  |  17 +-
 MoreLinq/CompatibilitySuppressions.xml        |  24 +
 MoreLinq/CountBy.cs                           |  14 +-
 MoreLinq/Experimental/Await.cs                |   2 +-
 MoreLinq/Extensions.g.cs                      |  12 +-
 MoreLinq/MoreLinq.csproj                      |   2 +-
 .../PublicAPI/net9.0/PublicAPI.Shipped.txt    |   1 +
 .../PublicAPI/net9.0/PublicAPI.Unshipped.txt  | 699 ++++++++++++++++++
 8 files changed, 756 insertions(+), 15 deletions(-)
 create mode 100644 MoreLinq/PublicAPI/net9.0/PublicAPI.Shipped.txt
 create mode 100644 MoreLinq/PublicAPI/net9.0/PublicAPI.Unshipped.txt

diff --git a/MoreLinq.Test/CountByTest.cs b/MoreLinq.Test/CountByTest.cs
index fa5cb369e..027c2979e 100644
--- a/MoreLinq.Test/CountByTest.cs
+++ b/MoreLinq.Test/CountByTest.cs
@@ -26,7 +26,7 @@ public class CountByTest
         [Test]
         public void CountBySimpleTest()
         {
-            var result = new[] { 1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 1, 2 }.CountBy(c => c);
+            var result = MoreEnumerable.CountBy([1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 1, 2 ], c => c);
 
             result.AssertSequenceEqual(
                 KeyValuePair.Create(1, 4),
@@ -40,7 +40,7 @@ public void CountBySimpleTest()
         [Test]
         public void CountByWithSecondOccurenceImmediatelyAfterFirst()
         {
-            var result = "jaffer".CountBy(c => c);
+            var result = MoreEnumerable.CountBy("jaffer", c => c);
 
             result.AssertSequenceEqual(
                 KeyValuePair.Create('j', 1),
@@ -53,7 +53,7 @@ public void CountByWithSecondOccurenceImmediatelyAfterFirst()
         [Test]
         public void CountByEvenOddTest()
         {
-            var result = Enumerable.Range(1, 100).CountBy(c => c % 2);
+            var result = MoreEnumerable.CountBy(Enumerable.Range(1, 100), c => c % 2);
 
             result.AssertSequenceEqual(
                 KeyValuePair.Create(1, 50),
@@ -63,7 +63,7 @@ public void CountByEvenOddTest()
         [Test]
         public void CountByWithEqualityComparer()
         {
-            var result = new[] { "a", "B", "c", "A", "b", "A" }.CountBy(c => c, StringComparer.OrdinalIgnoreCase);
+            var result = MoreEnumerable.CountBy(["a", "B", "c", "A", "b", "A"], c => c, StringComparer.OrdinalIgnoreCase);
 
             result.AssertSequenceEqual(
                 KeyValuePair.Create("a", 3),
@@ -76,7 +76,7 @@ public void CountByHasKeysOrderedLikeGroupBy()
         {
             var randomSequence = MoreEnumerable.Random(0, 100).Take(100).ToArray();
 
-            var countByKeys = randomSequence.CountBy(x => x).Select(x => x.Key);
+            var countByKeys = MoreEnumerable.CountBy(randomSequence, x => x).Select(x => x.Key);
             var groupByKeys = randomSequence.GroupBy(x => x).Select(x => x.Key);
 
             countByKeys.AssertSequenceEqual(groupByKeys);
@@ -85,7 +85,7 @@ public void CountByHasKeysOrderedLikeGroupBy()
         [Test]
         public void CountByIsLazy()
         {
-            _ = new BreakingSequence<string>().CountBy(BreakingFunc.Of<string, int>());
+            _ = MoreEnumerable.CountBy(new BreakingSequence<string>(), BreakingFunc.Of<string, int>());
         }
 
         [Test]
@@ -95,7 +95,7 @@ public void CountByWithSomeNullKeys()
             {
                 "foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"
             };
-            var result = ss.CountBy(s => s);
+            var result = MoreEnumerable.CountBy(ss, s => s);
 
             result.AssertSequenceEqual(
                 KeyValuePair.Create((string?)"foo", 2),
@@ -107,7 +107,8 @@ public void CountByWithSomeNullKeys()
         [Test]
         public void CountByWithSomeNullKeysAndEqualityComparer()
         {
-            var result = new[] { "a", "B", null, "c", "A", null, "b", "A" }.CountBy(c => c, StringComparer.OrdinalIgnoreCase);
+            string?[] source = ["a", "B", null, "c", "A", null, "b", "A"];
+            var result = MoreEnumerable.CountBy(source, c => c, StringComparer.OrdinalIgnoreCase);
 
             result.AssertSequenceEqual(
                 KeyValuePair.Create((string?)"a", 3),
diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml
index b7cc8ddaf..2a8ffc7cc 100644
--- a/MoreLinq/CompatibilitySuppressions.xml
+++ b/MoreLinq/CompatibilitySuppressions.xml
@@ -31,6 +31,30 @@
     <Left>lib/net6.0/MoreLinq.dll</Left>
     <Right>lib/net8.0/MoreLinq.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:MoreLinq.Extensions.CountByExtension.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})</Target>
+    <Left>lib/net8.0/MoreLinq.dll</Left>
+    <Right>lib/net9.0/MoreLinq.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:MoreLinq.Extensions.CountByExtension.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})</Target>
+    <Left>lib/net8.0/MoreLinq.dll</Left>
+    <Right>lib/net9.0/MoreLinq.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:MoreLinq.MoreEnumerable.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})</Target>
+    <Left>lib/net8.0/MoreLinq.dll</Left>
+    <Right>lib/net9.0/MoreLinq.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:MoreLinq.MoreEnumerable.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})</Target>
+    <Left>lib/net8.0/MoreLinq.dll</Left>
+    <Right>lib/net9.0/MoreLinq.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:MoreLinq.MoreEnumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)</Target>
diff --git a/MoreLinq/CountBy.cs b/MoreLinq/CountBy.cs
index 0ea540d81..a2e620fac 100644
--- a/MoreLinq/CountBy.cs
+++ b/MoreLinq/CountBy.cs
@@ -32,9 +32,13 @@ static partial class MoreEnumerable
         /// <param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
         /// <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
 
-        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
+        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+#if !NET9_0_OR_GREATER
+            this
+#endif
+            IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
-            return source.CountBy(keySelector, null);
+            return CountBy(source, keySelector, null);
         }
 
         /// <summary>
@@ -50,7 +54,11 @@ public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this I
         /// If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
         /// <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
 
-        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
+        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+#if !NET9_0_OR_GREATER
+            this
+#endif
+            IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
         {
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (keySelector == null) throw new ArgumentNullException(nameof(keySelector));
diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs
index dca801b51..5521a0df9 100644
--- a/MoreLinq/Experimental/Await.cs
+++ b/MoreLinq/Experimental/Await.cs
@@ -461,7 +461,7 @@ static IEnumerable<TResult> Impl(
                 var completed = false;
                 var cancellationTokenSource = new CancellationTokenSource();
 
-                var enumerator = source.Index().GetEnumerator();
+                var enumerator = MoreEnumerable.Index(source).GetEnumerator();
                 IDisposable disposable = enumerator; // disables AccessToDisposedClosure warnings
 
                 try
diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index 81e42062e..6d1802e77 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -1173,7 +1173,11 @@ public static partial class CountByExtension
         /// <param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
         /// <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
 
-        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
+        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+#if !NET9_0_OR_GREATER
+            this
+#endif
+            IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
             => MoreEnumerable.CountBy(source, keySelector);
 
         /// <summary>
@@ -1189,7 +1193,11 @@ public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this I
         /// If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
         /// <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
 
-        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
+        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+#if !NET9_0_OR_GREATER
+            this
+#endif
+            IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
             => MoreEnumerable.CountBy(source, keySelector, comparer);
 
     }
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index bf796f42b..f45d4bdc6 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -121,7 +121,7 @@
     <NeutralLanguage>en-US</NeutralLanguage>
     <VersionPrefix>4.3.1</VersionPrefix>
     <Authors>MoreLINQ Developers.</Authors>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0;net8.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0;net8.0;net9.0</TargetFrameworks>
     <DebugType>portable</DebugType>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>MoreLinq</AssemblyName>
diff --git a/MoreLinq/PublicAPI/net9.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net9.0/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/net9.0/PublicAPI.Shipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/MoreLinq/PublicAPI/net9.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net9.0/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..d59ac1739
--- /dev/null
+++ b/MoreLinq/PublicAPI/net9.0/PublicAPI.Unshipped.txt
@@ -0,0 +1,699 @@
+#nullable enable
+~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func<object, System.Collections.IEnumerable?>! selector) -> System.Collections.Generic.IEnumerable<object>!
+~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func<System.Collections.IEnumerable!, bool>! predicate) -> System.Collections.Generic.IEnumerable<object>!
+~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
+~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func<object, System.Collections.IEnumerable?>! selector) -> System.Collections.Generic.IEnumerable<object>!
+~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func<System.Collections.IEnumerable!, bool>! predicate) -> System.Collections.Generic.IEnumerable<object>!
+~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
+MoreLinq.Experimental.Async.ExperimentalEnumerable
+MoreLinq.Experimental.AwaitQueryOptions
+MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency.get -> int?
+MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder.get -> bool
+MoreLinq.Experimental.AwaitQueryOptions.Scheduler.get -> System.Threading.Tasks.TaskScheduler!
+MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(int? value) -> MoreLinq.Experimental.AwaitQueryOptions!
+MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(bool value) -> MoreLinq.Experimental.AwaitQueryOptions!
+MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.AwaitQueryOptions!
+MoreLinq.Experimental.ExperimentalEnumerable
+MoreLinq.Experimental.IAwaitQuery<T>
+MoreLinq.Experimental.IAwaitQuery<T>.Options.get -> MoreLinq.Experimental.AwaitQueryOptions!
+MoreLinq.Experimental.IAwaitQuery<T>.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery<T>!
+MoreLinq.Experimental.ICurrentBuffer<T>
+MoreLinq.Extensions.AcquireExtension
+MoreLinq.Extensions.AggregateExtension
+MoreLinq.Extensions.AggregateRightExtension
+MoreLinq.Extensions.AppendExtension
+MoreLinq.Extensions.AssertCountExtension
+MoreLinq.Extensions.AssertExtension
+MoreLinq.Extensions.AtLeastExtension
+MoreLinq.Extensions.AtMostExtension
+MoreLinq.Extensions.BacksertExtension
+MoreLinq.Extensions.BatchExtension
+MoreLinq.Extensions.CartesianExtension
+MoreLinq.Extensions.ChooseExtension
+MoreLinq.Extensions.CompareCountExtension
+MoreLinq.Extensions.ConsumeExtension
+MoreLinq.Extensions.CountBetweenExtension
+MoreLinq.Extensions.CountByExtension
+MoreLinq.Extensions.CountDownExtension
+MoreLinq.Extensions.DistinctByExtension
+MoreLinq.Extensions.DuplicatesExtension
+MoreLinq.Extensions.EndsWithExtension
+MoreLinq.Extensions.EquiZipExtension
+MoreLinq.Extensions.EvaluateExtension
+MoreLinq.Extensions.ExactlyExtension
+MoreLinq.Extensions.ExceptByExtension
+MoreLinq.Extensions.ExcludeExtension
+MoreLinq.Extensions.FallbackIfEmptyExtension
+MoreLinq.Extensions.FillBackwardExtension
+MoreLinq.Extensions.FillForwardExtension
+MoreLinq.Extensions.FirstExtension
+MoreLinq.Extensions.FirstOrDefaultExtension
+MoreLinq.Extensions.FlattenExtension
+MoreLinq.Extensions.FoldExtension
+MoreLinq.Extensions.ForEachExtension
+MoreLinq.Extensions.FullGroupJoinExtension
+MoreLinq.Extensions.FullJoinExtension
+MoreLinq.Extensions.GroupAdjacentExtension
+MoreLinq.Extensions.IndexByExtension
+MoreLinq.Extensions.IndexExtension
+MoreLinq.Extensions.InsertExtension
+MoreLinq.Extensions.InterleaveExtension
+MoreLinq.Extensions.LagExtension
+MoreLinq.Extensions.LastExtension
+MoreLinq.Extensions.LastOrDefaultExtension
+MoreLinq.Extensions.LeadExtension
+MoreLinq.Extensions.LeftJoinExtension
+MoreLinq.Extensions.MaxByExtension
+MoreLinq.Extensions.MaximaExtension
+MoreLinq.Extensions.MinByExtension
+MoreLinq.Extensions.MinimaExtension
+MoreLinq.Extensions.MoveExtension
+MoreLinq.Extensions.OrderByExtension
+MoreLinq.Extensions.OrderedMergeExtension
+MoreLinq.Extensions.PadExtension
+MoreLinq.Extensions.PadStartExtension
+MoreLinq.Extensions.PairwiseExtension
+MoreLinq.Extensions.PartialSortByExtension
+MoreLinq.Extensions.PartialSortExtension
+MoreLinq.Extensions.PartitionExtension
+MoreLinq.Extensions.PermutationsExtension
+MoreLinq.Extensions.PipeExtension
+MoreLinq.Extensions.PrependExtension
+MoreLinq.Extensions.PreScanExtension
+MoreLinq.Extensions.RandomSubsetExtension
+MoreLinq.Extensions.RankByExtension
+MoreLinq.Extensions.RankExtension
+MoreLinq.Extensions.RepeatExtension
+MoreLinq.Extensions.RightJoinExtension
+MoreLinq.Extensions.RunLengthEncodeExtension
+MoreLinq.Extensions.ScanByExtension
+MoreLinq.Extensions.ScanExtension
+MoreLinq.Extensions.ScanRightExtension
+MoreLinq.Extensions.SegmentExtension
+MoreLinq.Extensions.ShuffleExtension
+MoreLinq.Extensions.SingleExtension
+MoreLinq.Extensions.SingleOrDefaultExtension
+MoreLinq.Extensions.SkipLastExtension
+MoreLinq.Extensions.SkipUntilExtension
+MoreLinq.Extensions.SliceExtension
+MoreLinq.Extensions.SortedMergeExtension
+MoreLinq.Extensions.SplitExtension
+MoreLinq.Extensions.StartsWithExtension
+MoreLinq.Extensions.SubsetsExtension
+MoreLinq.Extensions.TagFirstLastExtension
+MoreLinq.Extensions.TakeEveryExtension
+MoreLinq.Extensions.TakeLastExtension
+MoreLinq.Extensions.TakeUntilExtension
+MoreLinq.Extensions.ThenByExtension
+MoreLinq.Extensions.ToArrayByIndexExtension
+MoreLinq.Extensions.ToDataTableExtension
+MoreLinq.Extensions.ToDelimitedStringExtension
+MoreLinq.Extensions.ToDictionaryExtension
+MoreLinq.Extensions.ToHashSetExtension
+MoreLinq.Extensions.ToLookupExtension
+MoreLinq.Extensions.TraceExtension
+MoreLinq.Extensions.TransposeExtension
+MoreLinq.Extensions.WindowExtension
+MoreLinq.Extensions.WindowLeftExtension
+MoreLinq.Extensions.WindowRightExtension
+MoreLinq.Extensions.ZipLongestExtension
+MoreLinq.Extensions.ZipShortestExtension
+MoreLinq.IExtremaEnumerable<T>
+MoreLinq.IExtremaEnumerable<T>.Take(int count) -> System.Collections.Generic.IEnumerable<T>!
+MoreLinq.IExtremaEnumerable<T>.TakeLast(int count) -> System.Collections.Generic.IEnumerable<T>!
+MoreLinq.MoreEnumerable
+MoreLinq.OrderByDirection
+MoreLinq.OrderByDirection.Ascending = 0 -> MoreLinq.OrderByDirection
+MoreLinq.OrderByDirection.Descending = 1 -> MoreLinq.OrderByDirection
+MoreLinq.SequenceException
+MoreLinq.SequenceException.SequenceException() -> void
+MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void
+MoreLinq.SequenceException.SequenceException(string? message) -> void
+static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<T>!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<T>!>! sources) -> System.Collections.Generic.IAsyncEnumerable<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<TResult1, TResult2, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<TResult1, TResult2, TResult3, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<TResult1, TResult2, TResult3, TResult4, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<System.IObservable<T>!, System.IObservable<TResult6>!>! accumulator6, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<System.IObservable<T>!, System.IObservable<TResult6>!>! accumulator6, System.Func<System.IObservable<T>!, System.IObservable<TResult7>!>! accumulator7, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<System.IObservable<T>!, System.IObservable<TResult6>!>! accumulator6, System.Func<System.IObservable<T>!, System.IObservable<TResult7>!>! accumulator7, System.Func<System.IObservable<T>!, System.IObservable<TResult8>!>! accumulator8, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Await<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery<TResult>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Await<T>(this System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<T>!>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion<T, TTaskResult, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, System.Threading.CancellationToken, System.Threading.Tasks.Task<TTaskResult>!>! evaluator, System.Func<T, System.Threading.Tasks.Task<TTaskResult>!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery<TResult>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Batch<TSource, TBucket, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Buffers.ArrayPool<TSource>! pool, System.Func<MoreLinq.Experimental.ICurrentBuffer<TSource>!, System.Collections.Generic.IEnumerable<TBucket>!>! bucketProjectionSelector, System.Func<System.Collections.Generic.IEnumerable<TBucket>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Buffers.ArrayPool<TSource>! pool, System.Func<MoreLinq.Experimental.ICurrentBuffer<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source, int value) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Memoize<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source, bool value) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle<T, TCardinality, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many, System.Func<TCardinality, T?, TResult>! resultSelector) -> TResult
+static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle<T, TCardinality>(this System.Collections.Generic.IEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value)
+static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
+static MoreLinq.Extensions.AcquireExtension.Acquire<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> TSource[]!
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, TAccumulate8 seed8, System.Func<TAccumulate8, T, TAccumulate8>! accumulator8, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, System.Func<TAccumulate1, TAccumulate2, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateRightExtension.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Func<TAccumulate, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.AggregateRightExtension.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> TAccumulate
+static MoreLinq.Extensions.AggregateRightExtension.AggregateRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> TSource
+static MoreLinq.Extensions.AppendExtension.Append<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.AssertCountExtension.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<int, int, System.Exception!>! errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.AssertCountExtension.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate, System.Func<TSource, System.Exception!>? errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.AtLeastExtension.AtLeast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static MoreLinq.Extensions.AtMostExtension.AtMost<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static MoreLinq.Extensions.BacksertExtension.Backsert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.BatchExtension.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.BatchExtension.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Func<T1, T2, T3, T4, T5, T6, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Func<T1, T2, T3, T4, T5, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Func<T1, T2, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.ChooseExtension.Choose<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, (bool, TResult)>! chooser) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.CompareCountExtension.CompareCount<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> int
+static MoreLinq.Extensions.ConsumeExtension.Consume<T>(this System.Collections.Generic.IEnumerable<T>! source) -> void
+static MoreLinq.Extensions.CountBetweenExtension.CountBetween<T>(this System.Collections.Generic.IEnumerable<T>! source, int min, int max) -> bool
+static MoreLinq.Extensions.CountByExtension.CountBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.Extensions.CountByExtension.CountBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.Extensions.CountDownExtension.CountDown<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Func<T, int?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.DistinctByExtension.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.DistinctByExtension.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
+static MoreLinq.Extensions.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.EquiZipExtension.EquiZip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.EvaluateExtension.Evaluate<T>(this System.Collections.Generic.IEnumerable<System.Func<T>!>! functions) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.ExactlyExtension.Exactly<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static MoreLinq.Extensions.ExceptByExtension.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.ExceptByExtension.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.ExcludeExtension.Exclude<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEnumerable<T>! fallback) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FillBackwardExtension.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FillBackwardExtension.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FillBackwardExtension.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FillForwardExtension.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FillForwardExtension.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FillForwardExtension.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.FirstExtension.First<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
+static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TResult>! folder) -> TResult
+static MoreLinq.Extensions.ForEachExtension.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T, int>! action) -> void
+static MoreLinq.Extensions.ForEachExtension.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> void
+static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
+static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
+static MoreLinq.Extensions.FullJoinExtension.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.FullJoinExtension.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.FullJoinExtension.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.FullJoinExtension.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static MoreLinq.Extensions.IndexByExtension.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.Extensions.IndexByExtension.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.Extensions.IndexExtension.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.Extensions.IndexExtension.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.Extensions.InsertExtension.Insert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.InterleaveExtension.Interleave<T>(this System.Collections.Generic.IEnumerable<T>! sequence, params System.Collections.Generic.IEnumerable<T>![]! otherSequences) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LagExtension.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LastExtension.Last<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
+static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
+static MoreLinq.Extensions.LeadExtension.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LeadExtension.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MinByExtension.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MinByExtension.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.Extensions.MoveExtension.Move<T>(this System.Collections.Generic.IEnumerable<T>! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.OrderByExtension.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.Extensions.OrderByExtension.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T, TKey>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+static MoreLinq.Extensions.PadStartExtension.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PadStartExtension.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PadStartExtension.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+static MoreLinq.Extensions.PairwiseExtension.Pairwise<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.PartitionExtension.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool?, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> (System.Collections.Generic.IEnumerable<T>! True, System.Collections.Generic.IEnumerable<T>! False)
+static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.Extensions.PermutationsExtension.Permutations<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static MoreLinq.Extensions.PipeExtension.Pipe<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.PrependExtension.Prepend<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PreScanExtension.PreScan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation, TSource identity) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RightJoinExtension.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.RightJoinExtension.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.RightJoinExtension.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.RightJoinExtension.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
+static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
+static MoreLinq.Extensions.ScanByExtension.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
+static MoreLinq.Extensions.ScanByExtension.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
+static MoreLinq.Extensions.ScanExtension.Scan<TSource, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, TState seed, System.Func<TState, TSource, TState>! transformation) -> System.Collections.Generic.IEnumerable<TState>!
+static MoreLinq.Extensions.ScanExtension.Scan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.ScanRightExtension.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> System.Collections.Generic.IEnumerable<TAccumulate>!
+static MoreLinq.Extensions.ScanRightExtension.ScanRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.SegmentExtension.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.Extensions.SegmentExtension.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.Extensions.SegmentExtension.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.Extensions.ShuffleExtension.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.ShuffleExtension.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.SingleExtension.Single<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
+static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
+static MoreLinq.Extensions.SkipLastExtension.SkipLast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.SkipUntilExtension.SkipUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.SliceExtension.Slice<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.SortedMergeExtension.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.SortedMergeExtension.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>! comparer, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.Extensions.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
+static MoreLinq.Extensions.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+static MoreLinq.Extensions.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static MoreLinq.Extensions.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool, bool, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.TakeEveryExtension.TakeEvery<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int step) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.TakeLastExtension.TakeLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.TakeUntilExtension.TakeUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.ThenByExtension.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.Extensions.ThenByExtension.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector) -> T[]!
+static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector) -> T[]!
+static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> TTable!
+static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table) -> TTable!
+static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> System.Data.DataTable!
+static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<bool>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<byte>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<char>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<decimal>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<double>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<float>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<int>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<long>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<sbyte>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<short>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<string!>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<uint>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<ulong>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<ushort>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string! delimiter) -> string!
+static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.Extensions.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.Extensions.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.Extensions.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string? format) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, string!>! formatter) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.TransposeExtension.Transpose<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.Extensions.WindowExtension.Window<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static MoreLinq.Extensions.WindowLeftExtension.WindowLeft<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static MoreLinq.Extensions.WindowRightExtension.WindowRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1?, T2?, T3?, T4?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1?, T2?, T3?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst?, TSecond?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Acquire<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> TSource[]!
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, TAccumulate8 seed8, System.Func<TAccumulate8, T, TAccumulate8>! accumulator8, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, System.Func<TAccumulate1, TAccumulate2, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Func<TAccumulate, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> TAccumulate
+static MoreLinq.MoreEnumerable.AggregateRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> TSource
+static MoreLinq.MoreEnumerable.Append<T>(System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate, System.Func<TSource, System.Exception!>? errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<int, int, System.Exception!>! errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.AtLeast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static MoreLinq.MoreEnumerable.AtMost<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static MoreLinq.MoreEnumerable.Backsert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Func<T1, T2, T3, T4, T5, T6, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Func<T1, T2, T3, T4, T5, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Cartesian<T1, T2, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Func<T1, T2, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Choose<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, (bool, TResult)>! chooser) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.CompareCount<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> int
+static MoreLinq.MoreEnumerable.Consume<T>(this System.Collections.Generic.IEnumerable<T>! source) -> void
+static MoreLinq.MoreEnumerable.CountBetween<T>(this System.Collections.Generic.IEnumerable<T>! source, int min, int max) -> bool
+static MoreLinq.MoreEnumerable.CountBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.MoreEnumerable.CountBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.MoreEnumerable.CountDown<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Func<T, int?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.DistinctBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.DistinctBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
+static MoreLinq.MoreEnumerable.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.EquiZip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Evaluate<T>(this System.Collections.Generic.IEnumerable<System.Func<T>!>! functions) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Exactly<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
+static MoreLinq.MoreEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Exclude<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEnumerable<T>! fallback) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.First<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
+static MoreLinq.MoreEnumerable.FirstOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TResult>! folder) -> TResult
+static MoreLinq.MoreEnumerable.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T, int>! action) -> void
+static MoreLinq.MoreEnumerable.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> void
+static MoreLinq.MoreEnumerable.From<T>(params System.Func<T>![]! functions) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.From<T>(System.Func<T>! function) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.From<T>(System.Func<T>! function1, System.Func<T>! function2, System.Func<T>! function3) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.From<T>(System.Func<T>! function1, System.Func<T>! function2) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
+static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
+static MoreLinq.MoreEnumerable.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Generate<TResult>(TResult initial, System.Func<TResult, TResult>! generator) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.GenerateByIndex<TResult>(System.Func<int, TResult>! generator) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
+static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
+static MoreLinq.MoreEnumerable.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.MoreEnumerable.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.MoreEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.MoreEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
+static MoreLinq.MoreEnumerable.Insert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Interleave<T>(this System.Collections.Generic.IEnumerable<T>! sequence, params System.Collections.Generic.IEnumerable<T>![]! otherSequences) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Last<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
+static MoreLinq.MoreEnumerable.LastOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
+static MoreLinq.MoreEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.MinBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.MinBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Move<T>(this System.Collections.Generic.IEnumerable<T>! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.MoreEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.MoreEnumerable.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.OrderedMerge<T, TKey>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+static MoreLinq.MoreEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+static MoreLinq.MoreEnumerable.Pairwise<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool?, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> (System.Collections.Generic.IEnumerable<T>! True, System.Collections.Generic.IEnumerable<T>! False)
+static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
+static MoreLinq.MoreEnumerable.Permutations<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static MoreLinq.MoreEnumerable.Pipe<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Prepend<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.PreScan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation, TSource identity) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable<double>!
+static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable<double>!
+static MoreLinq.MoreEnumerable.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Return<T>(T item) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
+static MoreLinq.MoreEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
+static MoreLinq.MoreEnumerable.Scan<TSource, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, TState seed, System.Func<TState, TSource, TState>! transformation) -> System.Collections.Generic.IEnumerable<TState>!
+static MoreLinq.MoreEnumerable.Scan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
+static MoreLinq.MoreEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
+static MoreLinq.MoreEnumerable.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> System.Collections.Generic.IEnumerable<TAccumulate>!
+static MoreLinq.MoreEnumerable.ScanRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.MoreEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.MoreEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Sequence<T>(T start) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Sequence<T>(T start, T stop) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Sequence<T>(T start, T stop, T step) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Single<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
+static MoreLinq.MoreEnumerable.SingleOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
+static MoreLinq.MoreEnumerable.SkipLast<T>(System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.SkipUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Slice<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>! comparer, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
+static MoreLinq.MoreEnumerable.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
+static MoreLinq.MoreEnumerable.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+static MoreLinq.MoreEnumerable.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static MoreLinq.MoreEnumerable.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+static MoreLinq.MoreEnumerable.TagFirstLast<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool, bool, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.TakeEvery<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int step) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.TakeLast<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.TakeUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.MoreEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
+static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
+static MoreLinq.MoreEnumerable.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector) -> T[]!
+static MoreLinq.MoreEnumerable.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector) -> T[]!
+static MoreLinq.MoreEnumerable.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> TTable!
+static MoreLinq.MoreEnumerable.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table) -> TTable!
+static MoreLinq.MoreEnumerable.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> System.Data.DataTable!
+static MoreLinq.MoreEnumerable.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<bool>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<byte>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<char>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<decimal>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<double>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<float>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<int>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<long>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<sbyte>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<short>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<string!>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<uint>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<ulong>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<ushort>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDelimitedString<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string! delimiter) -> string!
+static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Linq.ILookup<TKey, TValue>!
+static MoreLinq.MoreEnumerable.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string? format) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, string!>! formatter) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Transpose<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
+static MoreLinq.MoreEnumerable.TraverseBreadthFirst<T>(T root, System.Func<T, System.Collections.Generic.IEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.TraverseDepthFirst<T>(T root, System.Func<T, System.Collections.Generic.IEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Unfold<TState, T, TResult>(TState state, System.Func<TState, T>! generator, System.Func<T, bool>! predicate, System.Func<T, TState>! stateSelector, System.Func<T, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.Window<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static MoreLinq.MoreEnumerable.WindowLeft<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static MoreLinq.MoreEnumerable.WindowRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1?, T2?, T3?, T4?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1?, T2?, T3?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.ZipLongest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst?, TSecond?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static MoreLinq.MoreEnumerable.ZipShortest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
+static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions!