From 8372989fafae22d72b17269a51dac843580805b6 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Wed, 15 Nov 2023 08:52:05 +0100
Subject: [PATCH 1/9] Add .NET 8 target

---
 .editorconfig                                 |  12 +
 Directory.Build.props                         |   2 +-
 MoreLinq.Test/.editorconfig                   |   3 +
 MoreLinq.Test/Make.cs                         |  30 +
 MoreLinq.Test/MemoizeTest.cs                  |   2 +-
 MoreLinq.Test/MoreLinq.Test.csproj            |   2 +-
 MoreLinq.Test/OrderedMergeTest.cs             |   2 -
 MoreLinq.Test/SegmentTest.cs                  |   2 -
 MoreLinq.Test/SliceTest.cs                    |  13 +-
 MoreLinq.Test/ZipLongestTest.cs               |   8 +-
 MoreLinq/Experimental/Async/Merge.cs          |   4 +
 MoreLinq/Experimental/Await.cs                |   2 +
 MoreLinq/Flatten.cs                           |   3 +-
 MoreLinq/GroupAdjacent.cs                     |   2 +-
 MoreLinq/MoreLinq.csproj                      |   2 +-
 MoreLinq/Permutations.cs                      |   4 +-
 .../PublicAPI/net8.0/PublicAPI.Shipped.txt    | 691 ++++++++++++++++++
 .../PublicAPI/net8.0/PublicAPI.Unshipped.txt  |   1 +
 MoreLinq/RandomSubset.cs                      |   3 +
 MoreLinq/SequenceException.cs                 |  18 +-
 MoreLinq/UnreachableException.cs              |   8 +-
 MoreLinq/Usings.cs                            |   1 +
 appveyor.yml                                  |   2 +
 .../MoreLinq.ExtensionsGenerator.csproj       |   4 +-
 global.json                                   |   2 +-
 test.cmd                                      |   2 +
 test.sh                                       |   2 +-
 27 files changed, 800 insertions(+), 27 deletions(-)
 create mode 100644 MoreLinq.Test/Make.cs
 create mode 100644 MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
 create mode 100644 MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
 create mode 100644 MoreLinq/Usings.cs

diff --git a/.editorconfig b/.editorconfig
index 57e440765..bf62f14a8 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -86,3 +86,15 @@ dotnet_diagnostic.IDE0055.severity = suggestion
 
 # IDE0046: Convert to conditional expression
 dotnet_diagnostic.IDE0046.severity = suggestion
+
+# CA1510: Use 'ArgumentNullException.ThrowIfNull' instead of explicitly throwing a new exception instance
+# TODO: Remove post https://github.com/morelinq/MoreLINQ/issues/903
+dotnet_diagnostic.CA1510.severity = suggestion
+
+# CA1512: Use 'ArgumentOutOfRangeException.ThrowIfNegativeOrZero' instead of explicitly throwing a new exception instance
+# TODO: Remove post https://github.com/morelinq/MoreLINQ/issues/903
+dotnet_diagnostic.CA1512.severity = suggestion
+
+# CA1513: Use 'ObjectDisposedException.ThrowIf' instead of explicitly throwing a new exception instance
+# TODO: Remove post https://github.com/morelinq/MoreLINQ/issues/903
+dotnet_diagnostic.CA1513.severity = suggestion
diff --git a/Directory.Build.props b/Directory.Build.props
index ef2ed08ed..9fc11a600 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -3,7 +3,7 @@
     <LangVersion>11</LangVersion>
     <Nullable>enable</Nullable>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <AnalysisLevel>7.0-all</AnalysisLevel>
+    <AnalysisLevel>8.0-all</AnalysisLevel>
     <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
     <!-- Workaround for IDE0005 (Remove unnecessary usings/imports); see https://github.com/dotnet/roslyn/issues/41640 -->
     <NoWarn>EnableGenerateDocumentationFile</NoWarn>
diff --git a/MoreLinq.Test/.editorconfig b/MoreLinq.Test/.editorconfig
index ffc9fb911..e6073bfb4 100644
--- a/MoreLinq.Test/.editorconfig
+++ b/MoreLinq.Test/.editorconfig
@@ -35,6 +35,9 @@ dotnet_diagnostic.IDE0047.severity = suggestion
 
 [*{Test,Tests}.cs]
 
+# CA1861: Avoid constant arrays as arguments
+dotnet_diagnostic.CA1861.severity = none
+
 # IDE0022: Use expression/block body for methods
 dotnet_diagnostic.IDE0022.severity = none
 
diff --git a/MoreLinq.Test/Make.cs b/MoreLinq.Test/Make.cs
new file mode 100644
index 000000000..23e4cf873
--- /dev/null
+++ b/MoreLinq.Test/Make.cs
@@ -0,0 +1,30 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2018 Atif Aziz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+global using static MoreLinq.Test.Make;
+
+namespace MoreLinq.Test
+{
+    using System.Collections.Generic;
+
+    static class Make
+    {
+        public static IEnumerable<T> Seq<T>(params T[] values) =>
+            from value in values
+            select value;
+    }
+}
diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs
index 31ce2aeca..f8280e052 100644
--- a/MoreLinq.Test/MemoizeTest.cs
+++ b/MoreLinq.Test/MemoizeTest.cs
@@ -217,7 +217,7 @@ void Run()
         [Test]
         public static void MemoizeIteratorThrowsWhenCacheDisposedDuringIteration()
         {
-            var sequence = Enumerable.Range(1, 10);
+            var sequence = Seq(1, 2, 3);
             var memoized = sequence.Memoize();
             var disposable = (IDisposable)memoized;
 
diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj
index c30b247bb..0b6d42855 100644
--- a/MoreLinq.Test/MoreLinq.Test.csproj
+++ b/MoreLinq.Test/MoreLinq.Test.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <AssemblyTitle>MoreLinq.Test</AssemblyTitle>
-    <TargetFrameworks>net7.0;net6.0;net471</TargetFrameworks>
+    <TargetFrameworks>net8.0;net7.0;net6.0;net471</TargetFrameworks>
     <DebugType>portable</DebugType>
     <AssemblyName>MoreLinq.Test</AssemblyName>
     <OutputType Condition="'$(TargetFramework)' == 'net471'">Exe</OutputType>
diff --git a/MoreLinq.Test/OrderedMergeTest.cs b/MoreLinq.Test/OrderedMergeTest.cs
index 416e43c48..6efcc9574 100644
--- a/MoreLinq.Test/OrderedMergeTest.cs
+++ b/MoreLinq.Test/OrderedMergeTest.cs
@@ -24,8 +24,6 @@ namespace MoreLinq.Test
     [TestFixture]
     public class OrderedMergeTest
     {
-        static IEnumerable<T> Seq<T>(params T[] values) => values;
-
         public static readonly IEnumerable<ITestCaseData> TestData =
             from e in new[]
             {
diff --git a/MoreLinq.Test/SegmentTest.cs b/MoreLinq.Test/SegmentTest.cs
index e4b587120..0f8996d86 100644
--- a/MoreLinq.Test/SegmentTest.cs
+++ b/MoreLinq.Test/SegmentTest.cs
@@ -149,8 +149,6 @@ public void VerifyCanSegmentByPrevious()
             Assert.That(result.All(s => s.Count() == repCount), Is.True);
         }
 
-        static IEnumerable<T> Seq<T>(params T[] values) => values;
-
         public static readonly IEnumerable<ITestCaseData> TestData =
             from e in new[]
             {
diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs
index d7498b946..c17ea99f8 100644
--- a/MoreLinq.Test/SliceTest.cs
+++ b/MoreLinq.Test/SliceTest.cs
@@ -47,9 +47,13 @@ public void TestSliceIdentity()
             var sequenceA = Enumerable.Range(1, count);
             var sequenceB = sequenceA.ToList();
 
+#pragma warning disable IDE0057 // Use range operator (N/A)
+
             var resultA = sequenceA.Slice(0, count);
             var resultB = sequenceB.Slice(0, count);
 
+#pragma warning restore IDE0057 // Use range operator
+
             Assert.That(resultA, Is.EqualTo(sequenceA));
             Assert.That(resultB, Is.EqualTo(sequenceB));
         }
@@ -65,9 +69,14 @@ public void TestSliceFirstItem()
             const int count = 10;
             var sequenceA = Enumerable.Range(1, count);
             var sequenceB = sequenceA.ToList();
+
+#pragma warning disable IDE0057 // Use range operator (N/A)
+
             var resultA = sequenceA.Slice(0, 1);
             var resultB = sequenceB.Slice(0, 1);
 
+#pragma warning restore IDE0057 // Use range operator
+
             Assert.That(resultA, Is.EqualTo(sequenceA.Take(1)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Take(1)));
         }
@@ -122,7 +131,9 @@ public void TestSliceLongerThanSequence()
             var sequenceA = Enumerable.Range(1, count);
             var sequenceB = sequenceA.ToList();
             var resultA = sequenceA.Slice(count / 2, count);
-            var resultB = sequenceB.Slice(count / 2, count);
+            // .NET 8 introduced `Slice` on `List<T>` so use `AsEnumerable` to force the extension
+            // method to be invoked.
+            var resultB = sequenceB.AsEnumerable().Slice(count / 2, count);
 
             Assert.That(resultA, Is.EqualTo(sequenceA.Skip(count / 2).Take(count)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Skip(count / 2).Take(count)));
diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs
index 3d07993a5..6ead0148e 100644
--- a/MoreLinq.Test/ZipLongestTest.cs
+++ b/MoreLinq.Test/ZipLongestTest.cs
@@ -26,8 +26,6 @@ namespace MoreLinq.Test
     [TestFixture]
     public class ZipLongestTest
     {
-        static IEnumerable<T> Seq<T>(params T[] values) => values;
-
         public static readonly IEnumerable<ITestCaseData> TestData =
             from e in new[]
             {
@@ -44,10 +42,10 @@ from e in new[]
 
 
         [Test, TestCaseSource(nameof(TestData))]
-        public IEnumerable<(int, string)> ZipLongest(int[] first, string[] second)
+        public IEnumerable<(int, string)> ZipLongest(IEnumerable<int> first, IEnumerable<string> second)
         {
-            using var ts1 = TestingSequence.Of(first);
-            using var ts2 = TestingSequence.Of(second);
+            using var ts1 = first.AsTestingSequence();
+            using var ts2 = second.AsTestingSequence();
             return ts1.ZipLongest(ts2, Tuple.Create).ToArray();
         }
 
diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs
index 34130abef..7e6312b9b 100644
--- a/MoreLinq/Experimental/Async/Merge.cs
+++ b/MoreLinq/Experimental/Async/Merge.cs
@@ -180,7 +180,11 @@ async IAsyncEnumerable<T> Async([EnumeratorCancellation]CancellationToken cancel
                     // Signal cancellation to those in flight. Unfortunately, this relies on all
                     // iterators to honour the cancellation.
 
+#if NET8_0_OR_GREATER
+                    await thisCancellationTokenSource.CancelAsync().ConfigureAwait(false);
+#else
                     thisCancellationTokenSource.Cancel();
+#endif
 
                     // > The caller of an async-iterator method should only call `DisposeAsync()`
                     // > when the method completed or was suspended by a `yield return`.
diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs
index aa6e0a15f..abbfa0caa 100644
--- a/MoreLinq/Experimental/Await.cs
+++ b/MoreLinq/Experimental/Await.cs
@@ -697,7 +697,9 @@ await concurrencyGate.EnterAsync(cancellationToken)
         static class AwaitQuery
         {
             public static IAwaitQuery<T>
+#pragma warning disable CA1859 // Use concrete types when possible for improved performance (by-design)
                 Create<T>(
+#pragma warning restore CA1859 // Use concrete types when possible for improved performance
                     Func<AwaitQueryOptions, IEnumerable<T>> impl,
                     AwaitQueryOptions? options = null) =>
                 new AwaitQuery<T>(impl, options);
diff --git a/MoreLinq/Flatten.cs b/MoreLinq/Flatten.cs
index 564da9731..eaee331d2 100644
--- a/MoreLinq/Flatten.cs
+++ b/MoreLinq/Flatten.cs
@@ -20,7 +20,6 @@
 namespace MoreLinq
 {
     using System;
-    using System.Linq;
     using System.Collections;
     using System.Collections.Generic;
 
@@ -135,7 +134,7 @@ public static IEnumerable<
 
                 try
                 {
-                    while (stack.Any())
+                    while (stack.Count > 0)
                     {
                         e = stack.Pop();
 
diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs
index a79e58499..8cf89a5e3 100644
--- a/MoreLinq/GroupAdjacent.cs
+++ b/MoreLinq/GroupAdjacent.cs
@@ -295,7 +295,7 @@ static IEnumerable<TResult> GroupAdjacentImpl<TSource, TKey, TElement, TResult>(
             }
         }
 
-        static IGrouping<TKey, TElement> CreateGroupAdjacentGrouping<TKey, TElement>(TKey key, IList<TElement> members) =>
+        static Grouping<TKey, TElement> CreateGroupAdjacentGrouping<TKey, TElement>(TKey key, IList<TElement> members) =>
             Grouping.Create(key, members.IsReadOnly ? members : new ReadOnlyCollection<TElement>(members));
 
         static class Grouping
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index fea6ba41c..6ba17d493 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -120,7 +120,7 @@
     <NeutralLanguage>en-US</NeutralLanguage>
     <VersionPrefix>4.1.0</VersionPrefix>
     <Authors>MoreLINQ Developers.</Authors>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0;net8.0</TargetFrameworks>
     <DebugType>portable</DebugType>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>MoreLinq</AssemblyName>
diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs
index 52e354c60..f6cb840c4 100644
--- a/MoreLinq/Permutations.cs
+++ b/MoreLinq/Permutations.cs
@@ -167,8 +167,8 @@ void NextPermutation()
             /// be surprised to discover that all of the permutations looked the
             /// same.
             /// </remarks>
-            /// <returns>List of permuted source sequence values</returns>
-            IList<T> PermuteValueSet()
+            /// <returns>Array of permuted source sequence values</returns>
+            T[] PermuteValueSet()
             {
                 var permutedSet = new T[_permutation.Length];
                 for (var i = 0; i < _permutation.Length; i++)
diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..ce7910980
--- /dev/null
+++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
@@ -0,0 +1,691 @@
+#nullable enable
+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.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.MinByExtension
+MoreLinq.Extensions.MaximaExtension
+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) -> void
+MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void
+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.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.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.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, 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, 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, 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, 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, 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.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.Collections.Generic.IEnumerable<TSource>!
+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.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.Extensions.CountByExtension.CountBy<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<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.IEnumerable<TSource>!
+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.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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.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, 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, 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, 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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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<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.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.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+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.MinByExtension.MinBy<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.MaximaExtension.Maxima<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.MinimaExtension.Minima<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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+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.PadStartExtension.PadStart<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.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) -> 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, 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.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+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) -> 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.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.Collections.Generic.IEnumerable<T>!
+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.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IComparer<TKey>? 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.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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) -> 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, 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.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) -> 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.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+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.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) -> TTable!
+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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+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.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.Dictionary<TKey, TValue>!
+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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+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.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.Collections.Generic.IEnumerable<TSource>!
+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.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.MoreEnumerable.CountBy<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<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.IEnumerable<TSource>!
+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.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.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, 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>(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.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.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<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<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.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.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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, 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.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> 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.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.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.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<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.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.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+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.MinBy<TSource, TKey>(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.Maxima<TSource, TKey>(this 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.Minima<TSource, TKey>(this 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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+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.PadStart<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.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) -> System.Collections.Generic.IEnumerable<T>!
+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) -> 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.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.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) -> 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.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) -> 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.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.Collections.Generic.IEnumerable<T>!
+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.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
+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.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> 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.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) -> 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, 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.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) -> 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.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+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.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) -> TTable!
+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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+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.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>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+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.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!
+~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
+~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.MoreEnumerable.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>!
diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs
index d0716f57d..f5f0de015 100644
--- a/MoreLinq/RandomSubset.cs
+++ b/MoreLinq/RandomSubset.cs
@@ -76,8 +76,11 @@ static IEnumerable<T> RandomSubsetImpl<T>(IEnumerable<T> source, Random rand, Fu
 
             if (array.Length < subsetSize)
             {
+#pragma warning disable CA2208 // Instantiate argument exceptions correctly
+                               // TODO Throw InvalidOperationException instead?
                 throw new ArgumentOutOfRangeException(nameof(subsetSize),
                     "Subset size must be less than or equal to the source length.");
+#pragma warning restore CA2208 // Instantiate argument exceptions correctly
             }
 
             var m = 0;                // keeps track of count items shuffled
diff --git a/MoreLinq/SequenceException.cs b/MoreLinq/SequenceException.cs
index c2226587b..6c5088984 100644
--- a/MoreLinq/SequenceException.cs
+++ b/MoreLinq/SequenceException.cs
@@ -18,14 +18,13 @@
 namespace MoreLinq
 {
     using System;
-    using System.Runtime.Serialization;
 
     /// <summary>
     /// The exception that is thrown for a sequence that fails a condition.
     /// </summary>
 
     [Serializable]
-    public class SequenceException : Exception
+    public partial class SequenceException : Exception
     {
         const string DefaultMessage = "Error in sequence.";
 
@@ -55,7 +54,20 @@ public SequenceException(string? message) :
 
         public SequenceException(string? message, Exception? innerException) :
             base(string.IsNullOrEmpty(message) ? DefaultMessage : message, innerException) { }
+    }
+}
 
+#if !NET7_0_OR_GREATER
+
+// BinaryFormatter serialization APIs are obsolete
+// https://learn.microsoft.com/en-us/dotnet/core/compatibility/serialization/7.0/binaryformatter-apis-produce-errors
+
+namespace MoreLinq
+{
+    using System.Runtime.Serialization;
+
+    partial class SequenceException
+    {
         /// <summary>
         /// Initializes a new instance of the <see cref="SequenceException"/> class
         /// with serialized data.
@@ -67,3 +79,5 @@ protected SequenceException(SerializationInfo info, StreamingContext context) :
             base(info, context) { }
     }
 }
+
+#endif // !NET8_0_OR_GREATER
diff --git a/MoreLinq/UnreachableException.cs b/MoreLinq/UnreachableException.cs
index 80e4cf0eb..23366f8ae 100644
--- a/MoreLinq/UnreachableException.cs
+++ b/MoreLinq/UnreachableException.cs
@@ -24,7 +24,11 @@
 // SOFTWARE.
 #endregion
 
-#if !NET7_0_OR_GREATER
+#if NET8_0_OR_GREATER
+
+global using UnreachableException = System.Diagnostics.UnreachableException;
+
+#else
 
 namespace MoreLinq
 {
@@ -55,4 +59,4 @@ public UnreachableException(string? message, Exception? innerException) :
     }
 }
 
-#endif // !NET7_0_OR_GREATER
+#endif // NET8_0_OR_GREATER
diff --git a/MoreLinq/Usings.cs b/MoreLinq/Usings.cs
new file mode 100644
index 000000000..5f282702b
--- /dev/null
+++ b/MoreLinq/Usings.cs
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/appveyor.yml b/appveyor.yml
index 27d35a0ad..98a25c24b 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -49,8 +49,10 @@ install:
 - git reset --hard
 - ps: if ($isWindows) { tools\dotnet-install.ps1 -JSonFile global.json }
 - ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 6.0.11 -SkipNonVersionedFiles }
+- ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 7.0.14 -SkipNonVersionedFiles }
 - sh: ./tools/dotnet-install.sh --jsonfile global.json
 - sh: ./tools/dotnet-install.sh --runtime dotnet --version 6.0.11 --skip-non-versioned-files
+- sh: ./tools/dotnet-install.sh --runtime dotnet --version 7.0.14 --skip-non-versioned-files
 - sh: export PATH="$HOME/.dotnet:$PATH"
 before_build:
 - dotnet --info
diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj
index e810d01e0..39132fd4d 100644
--- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj
+++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj
@@ -1,12 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="docopt.net" Version="0.8.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.7.0" />
-    <PackageReference Include="System.Collections.Immutable" Version="7.0.0" />
+    <PackageReference Include="System.Collections.Immutable" Version="8.0.0" />
   </ItemGroup>
 </Project>
diff --git a/global.json b/global.json
index 5bf3e71b6..391ba3c2a 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "7.0.200",
+    "version": "8.0.100",
     "rollForward": "latestFeature"
   }
 }
diff --git a/test.cmd b/test.cmd
index 1cc6d54be..640f802b9 100644
--- a/test.cmd
+++ b/test.cmd
@@ -8,6 +8,8 @@ setlocal
 if not defined SKIP_TEST_BUILD set SKIP_TEST_BUILD=false
 if %SKIP_TEST_BUILD%==false call build || exit /b 1
 call :clean ^
+  && call :test net8.0 Debug ^
+  && call :test net8.0 Release ^
   && call :test net7.0 Debug ^
   && call :test net7.0 Release ^
   && call :test net6.0 Debug ^
diff --git a/test.sh b/test.sh
index 2548482d1..fbe65fd50 100755
--- a/test.sh
+++ b/test.sh
@@ -12,7 +12,7 @@ if [[ -z "$1" ]]; then
 else
     configs="$1"
 fi
-for f in net6.0 net7.0; do
+for f in net6.0 net7.0 net8.0; do
     for c in $configs; do
         dotnet test --no-build -c $c -f $f --settings MoreLinq.Test/coverlet.runsettings MoreLinq.Test
         TEST_RESULTS_DIR="$(ls -dc MoreLinq.Test/TestResults/* | head -1)"

From b693f49d702801a55d359667ba51069088797c1a Mon Sep 17 00:00:00 2001
From: Stuart Turner <stuart@turner-isageek.com>
Date: Wed, 15 Nov 2023 09:13:03 -0600
Subject: [PATCH 2/9] net8 update

---
 MoreLinq.Test/MoreLinq.Test.csproj            |   2 +-
 MoreLinq/Experimental/Async/Merge.cs          |   4 +
 MoreLinq/MoreLinq.csproj                      |   2 +-
 MoreLinq/PendNode.cs                          |   4 +
 .../PublicAPI/net6.0/PublicAPI.Unshipped.txt  |   1 +
 .../PublicAPI/net8.0/PublicAPI.Shipped.txt    | 692 ++++++++++++++++++
 .../PublicAPI/net8.0/PublicAPI.Unshipped.txt  |   2 +
 .../netstandard2.0/PublicAPI.Unshipped.txt    |   1 +
 .../netstandard2.1/PublicAPI.Unshipped.txt    |   1 +
 MoreLinq/RandomSubset.cs                      |   2 +
 MoreLinq/SequenceException.cs                 |  11 -
 global.json                                   |   2 +-
 12 files changed, 710 insertions(+), 14 deletions(-)
 create mode 100644 MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
 create mode 100644 MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt

diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj
index c30b247bb..9b2ecfb77 100644
--- a/MoreLinq.Test/MoreLinq.Test.csproj
+++ b/MoreLinq.Test/MoreLinq.Test.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <AssemblyTitle>MoreLinq.Test</AssemblyTitle>
-    <TargetFrameworks>net7.0;net6.0;net471</TargetFrameworks>
+    <TargetFrameworks>net8.0;net6.0;net471</TargetFrameworks>
     <DebugType>portable</DebugType>
     <AssemblyName>MoreLinq.Test</AssemblyName>
     <OutputType Condition="'$(TargetFramework)' == 'net471'">Exe</OutputType>
diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs
index 34130abef..7e6312b9b 100644
--- a/MoreLinq/Experimental/Async/Merge.cs
+++ b/MoreLinq/Experimental/Async/Merge.cs
@@ -180,7 +180,11 @@ async IAsyncEnumerable<T> Async([EnumeratorCancellation]CancellationToken cancel
                     // Signal cancellation to those in flight. Unfortunately, this relies on all
                     // iterators to honour the cancellation.
 
+#if NET8_0_OR_GREATER
+                    await thisCancellationTokenSource.CancelAsync().ConfigureAwait(false);
+#else
                     thisCancellationTokenSource.Cancel();
+#endif
 
                     // > The caller of an async-iterator method should only call `DisposeAsync()`
                     // > when the method completed or was suspended by a `yield return`.
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index fea6ba41c..6ba17d493 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -120,7 +120,7 @@
     <NeutralLanguage>en-US</NeutralLanguage>
     <VersionPrefix>4.1.0</VersionPrefix>
     <Authors>MoreLINQ Developers.</Authors>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0;net8.0</TargetFrameworks>
     <DebugType>portable</DebugType>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>MoreLinq</AssemblyName>
diff --git a/MoreLinq/PendNode.cs b/MoreLinq/PendNode.cs
index 2bf363863..b2ed576f6 100644
--- a/MoreLinq/PendNode.cs
+++ b/MoreLinq/PendNode.cs
@@ -21,6 +21,10 @@ namespace MoreLinq
     using System.Collections;
     using System.Collections.Generic;
 
+#if NET8_0_OR_GREATER
+    using System.Diagnostics;
+#endif
+
     /// <summary>
     /// Prepend-Append node is a single linked-list of the discriminated union
     /// of an item to prepend, an item to append and the source.
diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
index 7dc5c5811..e9023b0b0 100644
--- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
@@ -1 +1,2 @@
 #nullable enable
+*REMOVED*MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..b393e18b7
--- /dev/null
+++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
@@ -0,0 +1,692 @@
+#nullable enable
+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.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.MinByExtension
+MoreLinq.Extensions.MaximaExtension
+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) -> void
+MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void
+MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
+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.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.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.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, 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, 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, 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, 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, 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.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.Collections.Generic.IEnumerable<TSource>!
+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.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.Extensions.CountByExtension.CountBy<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<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.IEnumerable<TSource>!
+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.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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.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, 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, 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, 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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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<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.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.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+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.MinByExtension.MinBy<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.MaximaExtension.Maxima<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.MinimaExtension.Minima<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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+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.PadStartExtension.PadStart<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.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) -> 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, 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.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+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) -> 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.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.Collections.Generic.IEnumerable<T>!
+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.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IComparer<TKey>? 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.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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) -> 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, 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.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) -> 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.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+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.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) -> TTable!
+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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+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.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.Dictionary<TKey, TValue>!
+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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+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.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.Collections.Generic.IEnumerable<TSource>!
+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.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.MoreEnumerable.CountBy<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<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.IEnumerable<TSource>!
+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.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.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, 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>(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.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.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<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<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.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.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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, 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.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> 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.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.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.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<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.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.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+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.MinBy<TSource, TKey>(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.Maxima<TSource, TKey>(this 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.Minima<TSource, TKey>(this 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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+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.PadStart<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.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) -> System.Collections.Generic.IEnumerable<T>!
+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) -> 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.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.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) -> 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.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) -> 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.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.Collections.Generic.IEnumerable<T>!
+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.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
+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.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> 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.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) -> 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, 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.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) -> 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.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+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.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) -> TTable!
+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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+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.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>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+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.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!
+~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
+~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.MoreEnumerable.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>!
diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..e9023b0b0
--- /dev/null
+++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
@@ -0,0 +1,2 @@
+#nullable enable
+*REMOVED*MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
index 7dc5c5811..e9023b0b0 100644
--- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
@@ -1 +1,2 @@
 #nullable enable
+*REMOVED*MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
index 7dc5c5811..e9023b0b0 100644
--- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
@@ -1 +1,2 @@
 #nullable enable
+*REMOVED*MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs
index d0716f57d..98bed2085 100644
--- a/MoreLinq/RandomSubset.cs
+++ b/MoreLinq/RandomSubset.cs
@@ -76,8 +76,10 @@ static IEnumerable<T> RandomSubsetImpl<T>(IEnumerable<T> source, Random rand, Fu
 
             if (array.Length < subsetSize)
             {
+#pragma warning disable CA2208 // Instantiate argument exceptions correctly
                 throw new ArgumentOutOfRangeException(nameof(subsetSize),
                     "Subset size must be less than or equal to the source length.");
+#pragma warning restore CA2208 // Instantiate argument exceptions correctly
             }
 
             var m = 0;                // keeps track of count items shuffled
diff --git a/MoreLinq/SequenceException.cs b/MoreLinq/SequenceException.cs
index c2226587b..b2c9c24ac 100644
--- a/MoreLinq/SequenceException.cs
+++ b/MoreLinq/SequenceException.cs
@@ -18,7 +18,6 @@
 namespace MoreLinq
 {
     using System;
-    using System.Runtime.Serialization;
 
     /// <summary>
     /// The exception that is thrown for a sequence that fails a condition.
@@ -55,15 +54,5 @@ public SequenceException(string? message) :
 
         public SequenceException(string? message, Exception? innerException) :
             base(string.IsNullOrEmpty(message) ? DefaultMessage : message, innerException) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="SequenceException"/> class
-        /// with serialized data.
-        /// </summary>
-        /// <param name="info">The object that holds the serialized object data.</param>
-        /// <param name="context">The contextual information about the source or destination.</param>
-
-        protected SequenceException(SerializationInfo info, StreamingContext context) :
-            base(info, context) { }
     }
 }
diff --git a/global.json b/global.json
index 5bf3e71b6..391ba3c2a 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "7.0.200",
+    "version": "8.0.100",
     "rollForward": "latestFeature"
   }
 }

From 1782a4994e136d83636b473fe158553b817bc2d8 Mon Sep 17 00:00:00 2001
From: Stuart Turner <stuart@turner-isageek.com>
Date: Wed, 15 Nov 2023 09:39:55 -0600
Subject: [PATCH 3/9] Fix tests for net8 changes

---
 MoreLinq.Test/MemoizeTest.cs | 3 ++-
 MoreLinq.Test/SliceTest.cs   | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs
index 31ce2aeca..d3f5570d0 100644
--- a/MoreLinq.Test/MemoizeTest.cs
+++ b/MoreLinq.Test/MemoizeTest.cs
@@ -217,7 +217,8 @@ void Run()
         [Test]
         public static void MemoizeIteratorThrowsWhenCacheDisposedDuringIteration()
         {
-            var sequence = Enumerable.Range(1, 10);
+            // .Select(x => x) here because net8+ `Enumerable.Range()` returns an `ICollection<>`
+            var sequence = Enumerable.Range(1, 10).Select(x => x);
             var memoized = sequence.Memoize();
             var disposable = (IDisposable)memoized;
 
diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs
index d7498b946..63ef18d03 100644
--- a/MoreLinq.Test/SliceTest.cs
+++ b/MoreLinq.Test/SliceTest.cs
@@ -48,7 +48,7 @@ public void TestSliceIdentity()
             var sequenceB = sequenceA.ToList();
 
             var resultA = sequenceA.Slice(0, count);
-            var resultB = sequenceB.Slice(0, count);
+            var resultB = sequenceB.AsEnumerable().Slice(0, count);
 
             Assert.That(resultA, Is.EqualTo(sequenceA));
             Assert.That(resultB, Is.EqualTo(sequenceB));
@@ -66,7 +66,7 @@ public void TestSliceFirstItem()
             var sequenceA = Enumerable.Range(1, count);
             var sequenceB = sequenceA.ToList();
             var resultA = sequenceA.Slice(0, 1);
-            var resultB = sequenceB.Slice(0, 1);
+            var resultB = sequenceB.AsEnumerable().Slice(0, 1);
 
             Assert.That(resultA, Is.EqualTo(sequenceA.Take(1)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Take(1)));
@@ -103,7 +103,7 @@ public void TestSliceSmallerThanSequence()
             var sequenceA = Enumerable.Range(1, count);
             var sequenceB = sequenceA.ToList();
             var resultA = sequenceA.Slice(4, 5);
-            var resultB = sequenceB.Slice(4, 5);
+            var resultB = sequenceB.AsEnumerable().Slice(4, 5);
 
             Assert.That(resultA, Is.EqualTo(sequenceA.Skip(4).Take(5)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Skip(4).Take(5)));
@@ -122,7 +122,7 @@ public void TestSliceLongerThanSequence()
             var sequenceA = Enumerable.Range(1, count);
             var sequenceB = sequenceA.ToList();
             var resultA = sequenceA.Slice(count / 2, count);
-            var resultB = sequenceB.Slice(count / 2, count);
+            var resultB = sequenceB.AsEnumerable().Slice(count / 2, count);
 
             Assert.That(resultA, Is.EqualTo(sequenceA.Skip(count / 2).Take(count)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Skip(count / 2).Take(count)));

From 17c6ecada9ebc5b17f803a167d567be64c6a1848 Mon Sep 17 00:00:00 2001
From: Stuart Turner <stuart@turner-isageek.com>
Date: Wed, 15 Nov 2023 10:00:36 -0600
Subject: [PATCH 4/9] Fix build issue

---
 bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj
index e810d01e0..7d9290557 100644
--- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj
+++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <ItemGroup>

From b2adfe6258eebff344adaeac083f175508b7bd7d Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Wed, 15 Nov 2023 20:37:40 +0100
Subject: [PATCH 5/9] Remove blank "Usings.cs"

---
 MoreLinq/Usings.cs | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 MoreLinq/Usings.cs

diff --git a/MoreLinq/Usings.cs b/MoreLinq/Usings.cs
deleted file mode 100644
index 5f282702b..000000000
--- a/MoreLinq/Usings.cs
+++ /dev/null
@@ -1 +0,0 @@
-
\ No newline at end of file

From b322f3d1a081e8b638e8bd7bccab1dfe7019b855 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Wed, 15 Nov 2023 23:34:13 +0100
Subject: [PATCH 6/9] Update API compatibility suppressions

---
 MoreLinq/CompatibilitySuppressions.xml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml
index ffe9243dc..1b532b5f8 100644
--- a/MoreLinq/CompatibilitySuppressions.xml
+++ b/MoreLinq/CompatibilitySuppressions.xml
@@ -1,6 +1,12 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- https://learn.microsoft.com/en-us/dotnet/fundamentals/package-validation/diagnostic-ids -->
 <Suppressions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)</Target>
+    <Left>lib/net6.0/MoreLinq.dll</Left>
+    <Right>lib/net8.0/MoreLinq.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:MoreLinq.MoreEnumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)</Target>

From 0ceda4202fdaa7289df04acc405f6cf2532e65f2 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Wed, 15 Nov 2023 23:48:57 +0100
Subject: [PATCH 7/9] Allow "UnreachableException" in .NET 7 targets where
 added

---
 MoreLinq/UnreachableException.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/MoreLinq/UnreachableException.cs b/MoreLinq/UnreachableException.cs
index 23366f8ae..137facb25 100644
--- a/MoreLinq/UnreachableException.cs
+++ b/MoreLinq/UnreachableException.cs
@@ -24,7 +24,7 @@
 // SOFTWARE.
 #endregion
 
-#if NET8_0_OR_GREATER
+#if NET7_0_OR_GREATER
 
 global using UnreachableException = System.Diagnostics.UnreachableException;
 
@@ -59,4 +59,4 @@ public UnreachableException(string? message, Exception? innerException) :
     }
 }
 
-#endif // NET8_0_OR_GREATER
+#endif // NET7_0_OR_GREATER

From 6abc4715ea1dd19d71736663c9b2963432bef24a Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Thu, 16 Nov 2023 00:31:01 +0100
Subject: [PATCH 8/9] Remove incorrect suppressions of IDE0057

---
 MoreLinq.Test/SliceTest.cs | 25 +++++++++----------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs
index c17ea99f8..f6b459f82 100644
--- a/MoreLinq.Test/SliceTest.cs
+++ b/MoreLinq.Test/SliceTest.cs
@@ -45,15 +45,11 @@ public void TestSliceIdentity()
         {
             const int count = 100;
             var sequenceA = Enumerable.Range(1, count);
-            var sequenceB = sequenceA.ToList();
-
-#pragma warning disable IDE0057 // Use range operator (N/A)
+            var sequenceB = sequenceA.ToList().AsEnumerable();
 
             var resultA = sequenceA.Slice(0, count);
             var resultB = sequenceB.Slice(0, count);
 
-#pragma warning restore IDE0057 // Use range operator
-
             Assert.That(resultA, Is.EqualTo(sequenceA));
             Assert.That(resultB, Is.EqualTo(sequenceB));
         }
@@ -68,15 +64,11 @@ public void TestSliceFirstItem()
         {
             const int count = 10;
             var sequenceA = Enumerable.Range(1, count);
-            var sequenceB = sequenceA.ToList();
-
-#pragma warning disable IDE0057 // Use range operator (N/A)
+            var sequenceB = sequenceA.ToList().AsEnumerable();
 
             var resultA = sequenceA.Slice(0, 1);
             var resultB = sequenceB.Slice(0, 1);
 
-#pragma warning restore IDE0057 // Use range operator
-
             Assert.That(resultA, Is.EqualTo(sequenceA.Take(1)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Take(1)));
         }
@@ -91,7 +83,8 @@ public void TestSliceLastItem()
         {
             const int count = 10;
             var sequenceA = Enumerable.Range(1, count);
-            var sequenceB = sequenceA.ToList();
+            var sequenceB = sequenceA.ToList().AsEnumerable();
+
             var resultA = sequenceA.Slice(count - 1, 1);
             var resultB = sequenceB.Slice(count - 1, 1);
 
@@ -110,7 +103,8 @@ public void TestSliceSmallerThanSequence()
         {
             const int count = 10;
             var sequenceA = Enumerable.Range(1, count);
-            var sequenceB = sequenceA.ToList();
+            var sequenceB = sequenceA.ToList().AsEnumerable();
+
             var resultA = sequenceA.Slice(4, 5);
             var resultB = sequenceB.Slice(4, 5);
 
@@ -129,11 +123,10 @@ public void TestSliceLongerThanSequence()
         {
             const int count = 100;
             var sequenceA = Enumerable.Range(1, count);
-            var sequenceB = sequenceA.ToList();
+            var sequenceB = sequenceA.ToList().AsEnumerable();
+
             var resultA = sequenceA.Slice(count / 2, count);
-            // .NET 8 introduced `Slice` on `List<T>` so use `AsEnumerable` to force the extension
-            // method to be invoked.
-            var resultB = sequenceB.AsEnumerable().Slice(count / 2, count);
+            var resultB = sequenceB.Slice(count / 2, count);
 
             Assert.That(resultA, Is.EqualTo(sequenceA.Skip(count / 2).Take(count)));
             Assert.That(resultB, Is.EqualTo(sequenceB.Skip(count / 2).Take(count)));

From a3b88be71ffd2205ca8cc5300fc65a80bc78fd5c Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Thu, 16 Nov 2023 19:29:32 +0100
Subject: [PATCH 9/9] Mark .NET 8 public API as technically unshipped

---
 .../PublicAPI/net8.0/PublicAPI.Shipped.txt    | 690 ------------------
 .../PublicAPI/net8.0/PublicAPI.Unshipped.txt  | 690 ++++++++++++++++++
 2 files changed, 690 insertions(+), 690 deletions(-)

diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
index ce7910980..7dc5c5811 100644
--- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
+++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt
@@ -1,691 +1 @@
 #nullable enable
-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.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.MinByExtension
-MoreLinq.Extensions.MaximaExtension
-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) -> void
-MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void
-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.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.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.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, 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, 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, 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, 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, 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.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.Collections.Generic.IEnumerable<TSource>!
-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.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
-static MoreLinq.Extensions.CountByExtension.CountBy<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<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.IEnumerable<TSource>!
-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.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
-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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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.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, 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, 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, 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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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<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.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.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
-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.MinByExtension.MinBy<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.MaximaExtension.Maxima<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.MinimaExtension.Minima<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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
-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.PadStartExtension.PadStart<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.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) -> 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, 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.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
-static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
-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) -> 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.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.Collections.Generic.IEnumerable<T>!
-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.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IComparer<TKey>? 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.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
-static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
-static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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) -> 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, 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.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) -> 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.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
-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.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
-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.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) -> TTable!
-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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
-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.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.Dictionary<TKey, TValue>!
-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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
-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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
-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.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.Collections.Generic.IEnumerable<TSource>!
-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.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
-static MoreLinq.MoreEnumerable.CountBy<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<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.IEnumerable<TSource>!
-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.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
-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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.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, 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>(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.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.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<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<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.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.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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, 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.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> 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.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.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.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<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.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.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
-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.MinBy<TSource, TKey>(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.Maxima<TSource, TKey>(this 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.Minima<TSource, TKey>(this 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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
-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.PadStart<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.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) -> System.Collections.Generic.IEnumerable<T>!
-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) -> 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.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.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) -> 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.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) -> 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.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.Collections.Generic.IEnumerable<T>!
-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.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
-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.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
-static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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) -> System.Collections.Generic.IEnumerable<int>!
-static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
-static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> 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.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) -> 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, 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.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) -> 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.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
-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.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
-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.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) -> TTable!
-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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
-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.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>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
-static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
-static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
-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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
-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.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!
-~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
-~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.MoreEnumerable.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>!
diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
index 7dc5c5811..ce7910980 100644
--- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
+++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt
@@ -1 +1,691 @@
 #nullable enable
+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.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.MinByExtension
+MoreLinq.Extensions.MaximaExtension
+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) -> void
+MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void
+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.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.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.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, 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, 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, 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, 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, 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.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.Collections.Generic.IEnumerable<TSource>!
+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.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.Extensions.CountByExtension.CountBy<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<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.IEnumerable<TSource>!
+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.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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.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, 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, 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, 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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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.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<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.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.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+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.MinByExtension.MinBy<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.MaximaExtension.Maxima<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.MinimaExtension.Minima<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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+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.PadStartExtension.PadStart<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.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) -> 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, 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.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
+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) -> 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.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.Collections.Generic.IEnumerable<T>!
+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.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.IComparer<TKey>? 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.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.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) -> 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, 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.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) -> 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.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+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.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) -> TTable!
+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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+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.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.Dictionary<TKey, TValue>!
+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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+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.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.Collections.Generic.IEnumerable<TSource>!
+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.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
+static MoreLinq.MoreEnumerable.CountBy<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<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.IEnumerable<TSource>!
+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.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.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.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.IEqualityComparer<TKey>? keyComparer) -> 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) -> 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, T fallback3, T fallback4) -> 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.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.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.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.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> 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.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.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, 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>(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.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.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<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<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.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.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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, 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.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> 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.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.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.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<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.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.MaxBy<TSource, TKey>(System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+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.MinBy<TSource, TKey>(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.Maxima<TSource, TKey>(this 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.Minima<TSource, TKey>(this 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.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.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.IComparer<TKey>? comparer) -> 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.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<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.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.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
+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.PadStart<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.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) -> System.Collections.Generic.IEnumerable<T>!
+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) -> 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.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.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) -> 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.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) -> 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.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.Collections.Generic.IEnumerable<T>!
+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.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
+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.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> 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.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> 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.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.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.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.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> 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.IEqualityComparer<T>? comparer) -> 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.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.IEqualityComparer<TKey>? comparer) -> 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) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
+static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> 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.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) -> 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, 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.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) -> 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.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
+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.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
+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.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) -> TTable!
+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>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
+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.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>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.ToHashSet<TSource>(System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+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.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<(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<System.Collections.Generic.KeyValuePair<TKey, TValue>>! 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.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
+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.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!
+~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
+~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.MoreEnumerable.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>!