diff --git a/MoreLinq/Extensions.ToDataTable.g.cs b/MoreLinq/Extensions.ToDataTable.g.cs
index b9165678e..20380243d 100644
--- a/MoreLinq/Extensions.ToDataTable.g.cs
+++ b/MoreLinq/Extensions.ToDataTable.g.cs
@@ -27,6 +27,8 @@
 //
 // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code
 
+#pragma warning disable RS0041 // Public members should not use oblivious types
+
 namespace MoreLinq.Extensions
 {
     using System;
diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index 2eccc5e1a..b25c873fb 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -27,6 +27,8 @@
 //
 // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code
 
+#pragma warning disable RS0041 // Public members should not use oblivious types
+
 namespace MoreLinq.Extensions
 {
     using System;
diff --git a/MoreLinq/Flatten.cs b/MoreLinq/Flatten.cs
index 09e107d01..564da9731 100644
--- a/MoreLinq/Flatten.cs
+++ b/MoreLinq/Flatten.cs
@@ -15,6 +15,8 @@
 // limitations under the License.
 #endregion
 
+#pragma warning disable RS0041 // Public members should not use oblivious types
+
 namespace MoreLinq
 {
     using System;
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index 5e05314d4..d2d6b1c9d 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -152,6 +152,10 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="3.3.4">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
@@ -254,6 +258,11 @@
     </Compile>
   </ItemGroup>
 
+  <ItemGroup>
+    <AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.Shipped.txt" />
+    <AdditionalFiles Include="PublicAPI/$(TargetFramework)/PublicAPI.Unshipped.txt" />
+  </ItemGroup>
+
   <Target Name="_CollectTextTemplates">
     <ItemGroup>
       <TextTemplate Include="%(None.Identity)" Condition="'%(None.Generator)' == 'TextTemplatingFileGenerator'">
diff --git a/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..1f9122f06
--- /dev/null
+++ b/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt
@@ -0,0 +1,678 @@
+#nullable enable
+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.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.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.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.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<System.Collections.Generic.IEnumerable<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<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.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>(this 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<System.Collections.Generic.IEnumerable<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<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.Concat<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this 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>(this 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>(this 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>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this 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.Windowed<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<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/net462/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..91fd806e7
--- /dev/null
+++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt
@@ -0,0 +1,684 @@
+#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.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<System.Collections.Generic.IEnumerable<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<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.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>(this 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<System.Collections.Generic.IEnumerable<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<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.Concat<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this 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>(this 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>(this 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>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this 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.Windowed<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<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/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..f6d66a9be
--- /dev/null
+++ b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt
@@ -0,0 +1,647 @@
+#nullable enable
+MoreLinq.Experimental.ExperimentalEnumerable
+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.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.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.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.Memoize<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<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.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<System.Collections.Generic.IEnumerable<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<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.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.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>(this 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<System.Collections.Generic.IEnumerable<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<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.Concat<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this 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>(this 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>(this 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.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>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this 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.Windowed<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<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 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/netstandard1.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..1f9122f06
--- /dev/null
+++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt
@@ -0,0 +1,678 @@
+#nullable enable
+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.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.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.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.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<System.Collections.Generic.IEnumerable<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<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.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>(this 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<System.Collections.Generic.IEnumerable<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<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.Concat<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this 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>(this 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>(this 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>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this 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.Windowed<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<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/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt
new file mode 100644
index 000000000..91fd806e7
--- /dev/null
+++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt
@@ -0,0 +1,684 @@
+#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.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<System.Collections.Generic.IEnumerable<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<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.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>(this 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<System.Collections.Generic.IEnumerable<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<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.Concat<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
+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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.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.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>(this 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>(this 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>(this 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>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
+static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this 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.Windowed<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<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/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
new file mode 100644
index 000000000..7dc5c5811
--- /dev/null
+++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
@@ -0,0 +1 @@
+#nullable enable
diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs
index da925e064..f058842af 100644
--- a/bld/ExtensionsGenerator/Program.cs
+++ b/bld/ExtensionsGenerator/Program.cs
@@ -329,6 +329,8 @@ public static partial class {m.Name}Extension
 //
 // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code
 
+#pragma warning disable RS0041 // Public members should not use oblivious types
+
 namespace MoreLinq.Extensions
 {{
 {string.Join("\n", imports)}