From 0737e95558e2ddd72bbf88f018d7cd8bdb050f59 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Mon, 29 Sep 2025 10:56:12 +0100
Subject: [PATCH 01/10] Update to .NET 10.0, add System.Linq.AsyncEnumerable
 refs

The main job at this stage was to ensure it can still compile. This starts the job of separating out the duplicated and different APIs, but most of that remains to be done.
---
 .../adr/0002-System-Linq-Async-In-Net10.md    | 44 ++++++++++++++++
 Ix.NET/Source/ApiCompare/ApiCompare.csproj    | 14 +++++
 .../Benchmarks.System.Interactive.csproj      |  2 +-
 Ix.NET/Source/FasterLinq/FasterLinq.csproj    |  2 +-
 Ix.NET/Source/Playground/Playground.csproj    | 18 +++++++
 ...m.Interactive.Async.Providers.Tests.csproj | 21 +++++++-
 .../System.Interactive.Async.Providers.csproj |  2 +-
 .../System.Interactive.Async.Tests.csproj     | 21 +++++++-
 .../System.Interactive.Async.csproj           |  8 +--
 .../System/Linq/IAsyncIListProvider.cs        | 52 +++++++++++++++++++
 .../System/Linq/Operators/Scan.cs             | 12 ++---
 .../System.Linq.Async.Queryable.Tests.csproj  | 21 +++++++-
 .../System.Linq.Async.Queryable.csproj        | 16 +++++-
 .../System.Linq.Async.Tests.csproj            | 21 +++++++-
 .../System.Linq.Async.csproj                  | 33 ++++++++++--
 .../System/Linq/AsyncEnumerablePartition.cs   |  2 +
 .../System/Linq/AsyncIterator.Opt.cs          |  2 +
 .../System/Linq/AsyncListPartition.cs         |  2 +
 .../System/Linq/IAsyncGrouping.cs             |  1 +
 .../System/Linq/IAsyncIListProvider.cs        |  9 ++++
 .../System/Linq/IOrderedAsyncEnumerable.cs    |  2 +
 .../System/Linq/Operators/Aggregate.cs        | 29 +++++++++++
 .../System/Linq/Operators/Grouping.cs         |  2 +
 .../System/Linq/Operators/Lookup.cs           |  2 +
 .../Linq/Operators/OrderedAsyncEnumerable.cs  |  2 +
 ...sts.System.Interactive.ApiApprovals.csproj | 13 +++++
 .../System.Linq.Async.csproj                  |  4 +-
 27 files changed, 334 insertions(+), 23 deletions(-)
 create mode 100644 Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs

diff --git a/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md b/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md
new file mode 100644
index 000000000..aae4be861
--- /dev/null
+++ b/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md
@@ -0,0 +1,44 @@
+# Migration of core `IAsyncEnumerable<T>` LINQ to runtime libraries
+
+.NET 10.0 provides LINQ support for `IAsyncEnumerable<T>` in the runtime class libraries. This effectively renders most of `System.Linq.Async` irrelevant. However, enabling a smooth transition to .NET 10.0 for existing users of this library is not entirely straightforward. This document describes how this will work.
+
+## Status
+
+Proposed.
+
+## Authors
+
+@idg10 ([Ian Griffiths](https://endjin.com/who-we-are/our-people/ian-griffiths/))
+
+
+## Context
+
+As an accident of history, the Rx.NET repository ended up being the de facto implementation of LINQ for `IAsyncEnumerable<T>` from 2019 when .NET Core 3 shipped up until late 2025 when .NET 10 shipped.
+
+This happened because Rx.NET had effectively been the incubator in which `IAsyncEnumerable<T>` was originally developed. Back before .NET Core 3.0, there was no such interface built into .NET, but Rx _did_ define this interface as part of its 'interactive extensions for .NET' feature. It also implented common LINQ operators for that interface.
+
+.NET Core 3.0 defined its own version of this `IAsyncEnumerable<T>`, but the .NET team did not choose to implement LINQ for it. Since the Rx.NET repository already had a fairly complete implentation of LINQ for its original version of `IAsyncEnumerable<T>`, it took only a fairly small amount of work to adapt this to the new version of `IAsyncEnumerable<T>` built into .NET. Thus `System.Linq.Async` was born.
+
+In .NET 10.0, the .NET team decided to take ownership of this functionality. For various reasons they did not simply adopt the existing code. (One reason is that .NET class library design guidelines have evolved over time, and some of the methods in Rx's `System.Linq.Async` did not align with those guidelines.) So the .NET team took the decision that they were not going to maintain backwards compatibility with the existing Rx.NET-originated `System.Linq.Async` library. Instead, there is a new `System.Linq.AsyncEnumerable` library that defines equivalent functionality, but implemented from scratch, and fully in conformance with current .NET class library design guidelines.
+
+Most of the API changes fall into one of these categories:
+
+1. Where `System.Linq.Async` defined methods taking an `IComparer<T>` and an associated overload without the `IComparer<T>`, `System.Linq.AsyncEnumerable` only defines the overload that takes the `IComparer<T>`, making it optional with a default value of `null`
+2. For certain operators (e.g. min, max, sum) `System.Linq.Async` defined methods operating directly on numerical sequences, and also ones that operate on sequences of any type, taking an addition argument to project each element to a numeric value; in `System.Linq.AsyncEnumerable`, these projection-based variants either have a different name (e.g. `MaxByAsync`) or simply don't exist (as with `SumAsync`)
+3. `System.Linq.Async` offered some adapters (`ToEnumerable`, `ToObservable`) that handled async operations in potentially risky ways (sync over async, or fire-and-forget respectively); `System.Linq.AsyncEnumerable` has chosen simply not to implement these at all
+
+There are also a couple of cases where functionality simply has not been reproduced. `System.Linq.Async` provides an `AsAsyncEnumerable` to enable deliberate type erasure.  TBD.
+
+
+## Decision
+
+The next `System.Linq.Async` release will:
+
+1. add a reference to `System.Linq.AsyncEnumerable`
+2. remove from publicly visible API (ref assemblies) all `IAsyncEnumerable<T>` extension methods for which direct replacements exist
+3. add [Obsolete] attribute for all remaining members of `AsyncEnumerable`
+4. mark `IAsyncGrouping` as obsolete
+5. TBD `IAsyncIListProvider` relocate?
+6. continue to provide the full API in the `lib` assemblies to provide binary compatibility
+
+
diff --git a/Ix.NET/Source/ApiCompare/ApiCompare.csproj b/Ix.NET/Source/ApiCompare/ApiCompare.csproj
index 174cbcc1f..905863c51 100644
--- a/Ix.NET/Source/ApiCompare/ApiCompare.csproj
+++ b/Ix.NET/Source/ApiCompare/ApiCompare.csproj
@@ -5,6 +5,20 @@
     <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
     <ProjectReference Include="..\System.Interactive.Async.Providers\System.Interactive.Async.Providers.csproj" />
     <ProjectReference Include="..\System.Interactive.Async\System.Interactive.Async.csproj" />
diff --git a/Ix.NET/Source/Benchmarks.System.Interactive/Benchmarks.System.Interactive.csproj b/Ix.NET/Source/Benchmarks.System.Interactive/Benchmarks.System.Interactive.csproj
index 90a39816c..748770549 100644
--- a/Ix.NET/Source/Benchmarks.System.Interactive/Benchmarks.System.Interactive.csproj
+++ b/Ix.NET/Source/Benchmarks.System.Interactive/Benchmarks.System.Interactive.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <Optimize>true</Optimize>
     <Configurations>Current Sources;Ix.net 3.1.1;Ix.net 3.2</Configurations>
   </PropertyGroup>
diff --git a/Ix.NET/Source/FasterLinq/FasterLinq.csproj b/Ix.NET/Source/FasterLinq/FasterLinq.csproj
index 8735c4467..5758ba8fc 100644
--- a/Ix.NET/Source/FasterLinq/FasterLinq.csproj
+++ b/Ix.NET/Source/FasterLinq/FasterLinq.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
 
     <NoWarn>$(NoWarn);IDE0007;IDE0034;IDE0040;IDE0063;IDE0090;IDE1006</NoWarn>
   </PropertyGroup>
diff --git a/Ix.NET/Source/Playground/Playground.csproj b/Ix.NET/Source/Playground/Playground.csproj
index 174cbcc1f..7396a7ba8 100644
--- a/Ix.NET/Source/Playground/Playground.csproj
+++ b/Ix.NET/Source/Playground/Playground.csproj
@@ -14,4 +14,22 @@
     <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
   </ItemGroup>
 
+  <!--
+  Since this includes code that uses the legacy System.Linq.Async package, we need prevent the compiler from using the .NET runtime library
+  System.Linq.AsyncEnumerable package.
+  So although we get this references transitively (or automatically on .NET 10.0+) we need to put them explicitly here to set aliases.
+  -->
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
 </Project>
diff --git a/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj b/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj
index 0f4fbb98c..3d26121a3 100644
--- a/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj
+++ b/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;net10.0;net8.0</TargetFrameworks>
     <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
@@ -15,6 +15,25 @@
     <ProjectReference Include="..\System.Interactive.Async.Providers\System.Interactive.Async.Providers.csproj" />
     <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
   </ItemGroup>
+  
+  <!--
+  Since this tests the System.Interactive.Async.Providers package, which has a dependency on the legacy System.Linq.Async.Queryable package,
+  we need prevent the compiler from using the .NET runtime library System.Linq.AsyncEnumerable package.
+  So although we get this references transitively (or automatically on .NET 10.0+) we need to put them explicitly here to set aliases.
+  -->
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
diff --git a/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj b/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj
index 5e214f941..aeafce882 100644
--- a/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj
+++ b/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Interactive Extensions Async Providers Library used to build query providers and express queries over async enumerable sequences.</Description>
     <AssemblyTitle>Interactive Extensions - Async Providers Library</AssemblyTitle>
-    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net8.0</TargetFrameworks>
     <PackageTags>Ix;Interactive;Extensions;Enumerable;Asynchronous</PackageTags>
   </PropertyGroup>
 
diff --git a/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj b/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj
index 99ef36d68..90dfd4327 100644
--- a/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj
+++ b/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;net10.0;net8.0</TargetFrameworks>
 
     <!--
       CA1510: Use ArgumentNullException.ThrowIfNull - not available on .NET 4.8
@@ -21,6 +21,25 @@
     <ProjectReference Include="..\System.Interactive.Async.Providers\System.Interactive.Async.Providers.csproj" />
     <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
   </ItemGroup>
+  
+  <!--
+  Since this tests the System.Interactive.Async.Providers package, which has a dependency on the legacy System.Linq.Async.Queryable package,
+  we need prevent the compiler from using the .NET runtime library System.Linq.AsyncEnumerable package.
+  So although we get this references transitively (or automatically on .NET 10.0+) we need to put them explicitly here to set aliases.
+  -->
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
diff --git a/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj b/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj
index aa02a1e92..a092c2c3a 100644
--- a/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj
+++ b/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Interactive Extensions Async Library used to express queries over asynchronous enumerable sequences.</Description>
     <AssemblyTitle>Interactive Extensions - Async Library</AssemblyTitle>
-    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net8.0</TargetFrameworks>
     <PackageTags>Ix;Interactive;Extensions;Enumerable;Asynchronous</PackageTags>
   </PropertyGroup>
 
@@ -24,8 +24,8 @@
     <EmbeddedResource Include="Properties\System.Interactive.Async.rd.xml" />
   </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107" />
   </ItemGroup>
-  
+
 </Project>
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs
new file mode 100644
index 000000000..052ba2b51
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    /// <summary>
+    /// An iterator that can produce an array or <see cref="List{TElement}"/> through an optimized path.
+    /// </summary>
+    /// <remarks>
+    /// This interface is primarily used for internal purposes as an optimization for LINQ operators. Its use is discouraged.
+    /// It was made public because it was originally defined in the <c>System.Linq.Async</c> package but also used in
+    /// <c>System.Interactive.Async</c>. Now that <c>System.Linq.Async</c> is being retired in favor of .NET 10.0's
+    /// <c>System.Linq.AsyncEnumerable</c>, the <c>System.Interactive.Async</c> package no longer takes a dependency on
+    /// <c>System.Linq.Async</c>, which is why it now defines its own version of this interface here. We can't put a type
+    /// forwarder in <c>System.Interactive.Async</c> to here because that would risk creating a circular dependency in
+    /// cases where an application managed to get out-of-sync versions of the two packages, so this interface is not
+    /// backwards compatible with the old one. If you were implementing this in your own types to get the associated
+    /// optimizations, be aware that this is not supported, but implementing this copy of the interface (in place of
+    /// the old version defined in the deprecated <c>System.Linq.Async</c> package) will continue to provide the
+    /// same (unsupported) behaviour.
+    /// </remarks>
+    public interface IAsyncIListProvider<TElement> : IAsyncEnumerable<TElement>
+    {
+        /// <summary>
+        /// Produce an array of the sequence through an optimized path.
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The array.</returns>
+        ValueTask<TElement[]> ToArrayAsync(CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Produce a <see cref="List{TElement}"/> of the sequence through an optimized path.
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The <see cref="List{TElement}"/>.</returns>
+        ValueTask<List<TElement>> ToListAsync(CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Returns the count of elements in the sequence.
+        /// </summary>
+        /// <param name="onlyIfCheap">If true then the count should only be calculated if doing
+        /// so is quick (sure or likely to be constant time), otherwise -1 should be returned.</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The number of elements.</returns>
+        ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken);
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Scan.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Scan.cs
index fa0aca1c1..d839f46c4 100644
--- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Scan.cs
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Scan.cs
@@ -16,7 +16,7 @@ public static partial class AsyncEnumerableEx
 
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence and returns each intermediate result.
-        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource}"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource}(IAsyncEnumerable{TSource}, Func{TSource, TSource, TSource}, CancellationToken)"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence and the result of the aggregation.</typeparam>
         /// <param name="source">An async-enumerable sequence to accumulate over.</param>
@@ -54,7 +54,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
-        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, Accumulate}"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, TAccumulate}(IAsyncEnumerable{TSource}, TAccumulate, Func{TAccumulate, TSource, TAccumulate}, CancellationToken)"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TAccumulate">The type of the result of the aggregation.</typeparam>
@@ -87,7 +87,7 @@ static async IAsyncEnumerable<TAccumulate> Core(IAsyncEnumerable<TSource> source
 
         /// <summary>
         /// Applies an asynchronous accumulator function over an async-enumerable sequence and returns each intermediate result.
-        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource}"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource}(IAsyncEnumerable{TSource}, Func{TSource, TSource, CancellationToken, ValueTask{TSource}}, CancellationToken)"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence and the result of the aggregation.</typeparam>
         /// <param name="source">An async-enumerable sequence to accumulate over.</param>
@@ -126,7 +126,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 #if !NO_DEEP_CANCELLATION
         /// <summary>
         /// Applies an asynchronous (cancellable) accumulator function over an async-enumerable sequence and returns each intermediate result.
-        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource}"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, TAccumulate}(IAsyncEnumerable{TSource}, TAccumulate, Func{TAccumulate, TSource, CancellationToken, ValueTask{TAccumulate}}, CancellationToken)"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence and the result of the aggregation.</typeparam>
         /// <param name="source">An async-enumerable sequence to accumulate over.</param>
@@ -165,7 +165,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
         /// <summary>
         /// Applies an asynchronous accumulator function over an async-enumerable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
-        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, Accumulate}"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, TAccumulate, TResult}(IAsyncEnumerable{TSource}, TAccumulate, Func{TAccumulate, TSource, CancellationToken, ValueTask{TAccumulate}}, Func{TAccumulate, CancellationToken, ValueTask{TResult}}, CancellationToken)"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TAccumulate">The type of the result of the aggregation.</typeparam>
@@ -199,7 +199,7 @@ static async IAsyncEnumerable<TAccumulate> Core(IAsyncEnumerable<TSource> source
 #if !NO_DEEP_CANCELLATION
         /// <summary>
         /// Applies an asynchronous (cancellable) accumulator function over an async-enumerable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
-        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, Accumulate}"/>.
+        /// For aggregation behavior with no intermediate results, see <see cref="AsyncEnumerable.AggregateAsync{TSource, TAccumulate, TResult}(IAsyncEnumerable{TSource}, TAccumulate, Func{TAccumulate, TSource, CancellationToken, ValueTask{TAccumulate}}, Func{TAccumulate, CancellationToken, ValueTask{TResult}}, CancellationToken)"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <typeparam name="TAccumulate">The type of the result of the aggregation.</typeparam>
diff --git a/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj b/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj
index b5a0dc04d..cdde11437 100644
--- a/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj
+++ b/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;net10.0;net8.0</TargetFrameworks>
     <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
@@ -16,6 +16,25 @@
     <ProjectReference Include="..\System.Linq.Async.Queryable\System.Linq.Async.Queryable.csproj" />
   </ItemGroup>
 
+  <!--
+  Since this tests the legacy System.Linq.Async.Queryable package, we need prevent the compiler from using the .NET runtime library
+  System.Linq.AsyncEnumerable package.
+  So although we get this references transitively (or automatically on .NET 10.0+) we need to put them explicitly here to set aliases.
+  -->
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj b/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj
index f653bc91a..20f3263f8 100644
--- a/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj
+++ b/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net10.0</TargetFrameworks>
     <Title>System.Linq.Async.Queryable</Title>
     <PackageTags>LINQ;async;streams;query;provider</PackageTags>
     <Description>Provides support for Language-Integrated Query (LINQ) over IAsyncQueryable&lt;T&gt; sequences with query providers.</Description>
@@ -11,6 +11,20 @@
     <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <!-- Although we get this transitively from System.Linq.Async, we need the alias to ensure we compile against the legacy System.Linq.Async -->
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
     <Compile Update="System\Linq\AsyncQueryable.Generated.cs">
       <DependentUpon>AsyncQueryable.Generated.tt</DependentUpon>
diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj b/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj
index ed1c232ef..2c4e2a59d 100644
--- a/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj
+++ b/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;net10.0;net8.0</TargetFrameworks>
 
     <!--
     CA1510: Use ArgumentNullException.ThrowIfNull - not available on .NET 4.8
@@ -44,6 +44,25 @@
     <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
   </ItemGroup>
 
+  <!--
+  Since this tests the legacy System.Linq.Async package, we need prevent the compiler from using the .NET runtime library
+  System.Linq.AsyncEnumerable package.
+  So although we get this references transitively (or automatically on .NET 10.0+) we need to put them explicitly here to set aliases.
+  -->
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
diff --git a/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj
index 8c7df9bd2..c700c5b0f 100644
--- a/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj
+++ b/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net10.0</TargetFrameworks>
     <Title>System.Linq.Async</Title>    
     <PackageTags>LINQ;async;streams;query</PackageTags>
     <Description>Provides support for Language-Integrated Query (LINQ) over IAsyncEnumerable&lt;T&gt; sequences.</Description>  
@@ -16,6 +16,17 @@
           Pack="true" />
   </ItemGroup>
 
+  <PropertyGroup>
+    <!--
+    The ref assembly define the public API visible at compile time, so it should not include any methods for which
+    System.Linq.AsyncEnumerable defines source-compatible replacements, because their continued availability would
+    cause compile-time ambiguity.
+    We retain the code because we continue to make these methods availabe in the runtime assembly (in the lib folder)
+    to provide binary compatibility. This project builds the runtime assembly, so we need to include these methods.
+    -->
+    <DefineConstants>$(DefineConstants);INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES</DefineConstants>
+  </PropertyGroup>
+
   <!--
   These warnings occur because we are deliberately creating a lib/ref mismatch. There doesn't seem to be
   an official way to do that, so we have to suppress the warnings.
@@ -27,8 +38,9 @@
     <!--
     NU5128: lib/ref mismatch. This is deliberate, as explained in the ADR.
     NU5131: spurious missing file errors. It appears that the build is confused by what we're doing.
+    CS0618: Type or member is obsolete - this whole library is essentially obsolete, so internal use of obsolete features is OK and widespread.
     -->
-    <NoWarn>$(NoWarn);NU5128;NU5131</NoWarn>
+    <NoWarn>$(NoWarn);NU5128;NU5131;CS0618</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -57,10 +69,25 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Condition="'$(TargetFramework)' == 'net48' or '$(TargetFramework)' == 'netstandard2.0' " Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />
+    <!--<PackageReference Condition="'$(TargetFramework)' == 'net48' or '$(TargetFramework)' == 'netstandard2.0' " Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />-->
     <ProjectReference Include="..\System.Linq.Async.SourceGenerator\System.Linq.Async.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" Private="false" />
   </ItemGroup>
 
+
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+    
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
     <Compile Update="System\Linq\AsyncEnumerable.AsyncOverloads.cs">
       <DesignTime>True</DesignTime>
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs
index 9e84bd79a..71ea00c74 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs
@@ -11,6 +11,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     /// <summary>
     /// An iterator that yields the items of part of an <see cref="IAsyncEnumerable{TSource}"/>.
     /// </summary>
@@ -379,4 +380,5 @@ private static async ValueTask<uint> SkipAndCountAsync(uint index, IAsyncEnumera
             return index;
         }
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs
index 045300b90..4bdf37667 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs
@@ -8,6 +8,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     internal partial class AsyncIteratorBase<TSource>
     {
         public virtual IAsyncEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
@@ -44,4 +45,5 @@ public virtual IAsyncEnumerable<TSource> Where(Func<TSource, CancellationToken,
         }
 #endif
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs
index 0ab5e9149..b58183572 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs
@@ -11,6 +11,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     /// <summary>
     /// An iterator that yields the items of part of an <see cref="IList{TSource}"/>.
     /// </summary>
@@ -182,4 +183,5 @@ public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancella
             return new ValueTask<int>(Count);
         }
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncGrouping.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncGrouping.cs
index f89e9077b..e746d3413 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncGrouping.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncGrouping.cs
@@ -6,6 +6,7 @@
 
 namespace System.Linq
 {
+    // TODO: System.Linq does this as an IAsyncEnumerable<IGrouping<TKey, TElement>>
     public interface IAsyncGrouping<out TKey, out TElement> : IAsyncEnumerable<TElement>
     {
         TKey Key { get; }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs
index 133742620..ee053df3d 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs
@@ -11,6 +11,15 @@ namespace System.Linq
     /// <summary>
     /// An iterator that can produce an array or <see cref="List{TElement}"/> through an optimized path.
     /// </summary>
+    /// <remarks>
+    /// This interface is primarily used for internal purposes as an optimization for LINQ operators. It was made public because
+    /// it was defined in the <c>System.Linq.Async</c> package but also used in <c>System.Interactive.Async</c>. Now that
+    /// <c>System.Linq.Async</c> is being retired in favor of .NET 10.0's <c>System.Linq.AsyncEnumerable</c>, the
+    /// <c>System.Interactive.Async</c> package no longer takes a dependency on <c>System.Linq.Async</c>, and therefore defines
+    /// its own version of this interface. We can't replace this with a type forwarder here because that would risk creating a
+    /// circular dependency in cases where an application managed to get out-of-sync versions of the two packages.
+    /// </remarks>
+    [Obsolete("Use the definition of this type in the System.Interactive.Async NuGet package System.Linq.Async instead.")] // Can't use a type forwarder because 
     public interface IAsyncIListProvider<TElement> : IAsyncEnumerable<TElement>
     {
         /// <summary>
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs
index d7093b314..f50884996 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs
@@ -8,6 +8,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     /// <summary>
     /// Represents a sorted async-enumerable sequence.
     /// </summary>
@@ -45,5 +46,6 @@ public interface IOrderedAsyncEnumerable<out TElement> : IAsyncEnumerable<TEleme
         /// <returns>An ordered async-enumerable whose elements are sorted according to a key.</returns>
         IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey>? comparer, bool descending);
 #endif
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs
index 255921225..0ee37871c 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.aggregateasync?view=net-9.0-pp#system-linq-asyncenumerable-aggregateasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-0-0))-system-threading-cancellationtoken)
+        // public static ValueTask<TSource> AggregateAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> func, CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence.
         /// For aggregation behavior with incremental intermediate results, see System.Interactive.Async.AsyncEnumerableEx.Scan{TSource}.
@@ -50,6 +54,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return acc;
             }
         }
+#endif
 
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence.
@@ -63,6 +68,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
         private static ValueTask<TSource> AggregateAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -93,7 +99,16 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.aggregateasync?view=net-9.0-pp#system-linq-asyncenumerable-aggregateasync-3(system-collections-generic-iasyncenumerable((-0))-1-system-func((-1-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((-1))))-system-func((-1-system-threading-cancellationtoken-system-threading-tasks-valuetask((-2))))-system-threading-cancellationtoken)
+        // public static ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(
+        //  this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> func, Func<TAccumulate, CancellationToken, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default);
+        // Corresponds to:
+        // public static ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(
+        //  this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default) { }
+
         [GenerateAsyncOverload]
+        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
         private static ValueTask<TSource> AggregateAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, CancellationToken, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -124,6 +139,11 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.aggregateasync?view=net-9.0-pp#system-linq-asyncenumerable-aggregateasync-2(system-collections-generic-iasyncenumerable((-0))-1-system-func((-1-0-1))-system-threading-cancellationtoken)
+        //public static ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
         /// For aggregation behavior with incremental intermediate results, see System.Interactive.Async.AsyncEnumerableEx.Scan{TSource, Accumulate}".
@@ -158,6 +178,7 @@ static async ValueTask<TAccumulate> Core(IAsyncEnumerable<TSource> source, TAccu
                 return acc;
             }
         }
+#endif
 
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
@@ -172,6 +193,7 @@ static async ValueTask<TAccumulate> Core(IAsyncEnumerable<TSource> source, TAccu
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="accumulator"/> is <see langword="null"/>.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
         private static ValueTask<TAccumulate> AggregateAwaitAsyncCore<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -196,6 +218,7 @@ static async ValueTask<TAccumulate> Core(IAsyncEnumerable<TSource> source, TAccu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
         private static ValueTask<TAccumulate> AggregateAwaitWithCancellationAsyncCore<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -219,6 +242,10 @@ static async ValueTask<TAccumulate> Core(IAsyncEnumerable<TSource> source, TAccu
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.aggregateasync?view=net-9.0-pp#system-linq-asyncenumerable-aggregateasync-3(system-collections-generic-iasyncenumerable((-0))-1-system-func((-1-0-1))-system-func((-1-2))-system-threading-cancellationtoken)
+        // public static ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector, CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value,
         /// and the specified result selector function is used to select the result value.
@@ -257,6 +284,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, TAccumula
                 return resultSelector(acc);
             }
         }
+#endif
 
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value,
@@ -273,6 +301,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, TAccumula
         /// <returns>A ValueTask containing the value obtained by applying the result selector to the final accumulator value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="accumulator"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
         private static ValueTask<TResult> AggregateAwaitAsyncCore<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs
index 218bbb764..4ec45dca0 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs
@@ -10,6 +10,7 @@
 
 namespace System.Linq.Internal
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     /// Adapted from System.Linq.Grouping from .NET Framework
     /// Source: https://github.com/dotnet/corefx/blob/b90532bc97b07234a7d18073819d019645285f1c/src/System.Linq/src/System/Linq/Grouping.cs#L64
     internal class Grouping<TKey, TElement> : IGrouping<TKey, TElement>, IList<TElement>, IAsyncGrouping<TKey, TElement>
@@ -106,4 +107,5 @@ IAsyncEnumerator<TElement> IAsyncEnumerable<TElement>.GetAsyncEnumerator(Cancell
             return this.ToAsyncEnumerable().GetAsyncEnumerator(cancellationToken);
         }
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs
index 854f1583d..0a468e528 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs
@@ -11,6 +11,7 @@
 
 namespace System.Linq.Internal
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     internal class Lookup<TKey, TElement> : ILookup<TKey, TElement>, IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>
     {
         private readonly IEqualityComparer<TKey> _comparer;
@@ -647,4 +648,5 @@ ValueTask<IAsyncGrouping<TKey, TElement>[]> IAsyncIListProvider<IAsyncGrouping<T
             return new ValueTask<IAsyncGrouping<TKey, TElement>[]>(array);
         }
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs
index 54df9aa8f..717fcc925 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs
@@ -9,6 +9,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     // NB: Large portions of the implementation are based on https://github.com/dotnet/corefx/blob/master/src/System.Linq/src/System/Linq/OrderedEnumerable.cs.
 
     internal abstract class OrderedAsyncEnumerable<TElement> : AsyncIterator<TElement>, IOrderedAsyncEnumerable<TElement>, IAsyncPartition<TElement>
@@ -1216,4 +1217,5 @@ internal override async ValueTask SetElement(TElement element, CancellationToken
         }
     }
 #endif
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj
index a6022437c..56606a674 100644
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj
@@ -9,6 +9,19 @@
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
+                      Aliases="SystemLinqAsyncEnumerable" />
+  </ItemGroup>
+
+  <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
+    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+      <Reference Condition="'%(Reference.AssemblyName)' == 'System.Linq.AsyncEnumerable'">
+        <Aliases>SystemLinqAsyncEnumerable</Aliases>
+      </Reference>
+    </ItemGroup>
+  </Target>
+
   <ItemGroup>
     <Compile Remove="Api\*.verified.cs" />
     <Compile Remove="Api\*.received.cs" />
diff --git a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
index c2de741b9..7c46349cd 100644
--- a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
+++ b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
@@ -11,13 +11,13 @@
     <AssemblyName>System.Linq.Async</AssemblyName>
   </PropertyGroup>
 
-<PropertyGroup>
+  <PropertyGroup>
       <!--
     IDE0301 uses collection expressions in places where they don't necessarily have the same effect, which we want to avoid in case of possible compatibility issues.
     IDE0305 wants to turn things like list.ToArray into [..list], which we don't find to be an improvement in readability. -->
     <NoWarn>$(NoWarn);IDE0301;IDE0305</NoWarn>
 
-</PropertyGroup>
+  </PropertyGroup>
   <ItemGroup>
     <PackageReference Condition="'$(TargetFramework)' == 'net48' or '$(TargetFramework)' == 'netstandard2.0'" Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />
     

From a5e3a7fc1cf8949ac8877863190571c7ac2d3325 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Mon, 29 Sep 2025 17:19:06 +0100
Subject: [PATCH 02/10] Fix ref assembly build

Turns out the solution doesn't build the ref assemblies and they weren't building.

I also needed to modify the async code generator to correctly handle #if-ed out code. Turns out it was stripping the directives and then copying the disabled block of text in as leading trivia! This had the effect of copying #if-ed out methods into the generated code, making them reappear.

I've also worked through the first four files of operators.
---
 .../AsyncOverloadsGenerator.cs                | 31 +++++++++---
 .../Properties/launchSettings.json            | 11 +++++
 .../System.Linq.Async.SourceGenerator.csproj  |  1 +
 .../System/Linq/AsyncIterator.Opt.cs          |  2 -
 .../System/Linq/IOrderedAsyncEnumerable.cs    |  2 +-
 .../System/Linq/Operators/Aggregate.cs        | 13 ++---
 .../System/Linq/Operators/All.cs              |  6 +++
 .../System/Linq/Operators/Any.cs              |  7 +++
 .../System/Linq/Operators/AppendPrepend.cs    |  6 +++
 .../System/Linq/Operators/GroupBy.cs          | 47 +++++++++++++++++++
 .../System/Linq/Operators/Grouping.cs         |  2 -
 .../System/Linq/Operators/Lookup.cs           |  2 -
 .../System/Linq/Operators/OrderBy.cs          |  4 +-
 .../System/Linq/Operators/Select.cs           |  5 ++
 .../Linq/Operators/ToAsyncEnumerable.cs       |  2 +
 .../System.Linq.Async.csproj                  |  8 ++--
 16 files changed, 126 insertions(+), 23 deletions(-)
 create mode 100644 Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json

diff --git a/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs b/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
index b0c27ecfe..2856ee306 100644
--- a/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
+++ b/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
@@ -33,12 +33,13 @@ public void Execute(GeneratorExecutionContext context)
             if (context.SyntaxReceiver is not SyntaxReceiver syntaxReceiver) return;
 
             var options = GetGenerationOptions(context);
+            var attributeSymbol = GetAsyncOverloadAttributeSymbol(context);
             var methodsBySyntaxTree = GetMethodsGroupedBySyntaxTree(context, syntaxReceiver);
 
             foreach (var grouping in methodsBySyntaxTree)
                 context.AddSource(
                     $"{Path.GetFileNameWithoutExtension(grouping.SyntaxTree.FilePath)}.AsyncOverloads",
-                    GenerateOverloads(grouping, options));
+                    GenerateOverloads(grouping, options, context, attributeSymbol));
         }
 
         private static GenerationOptions GetGenerationOptions(GeneratorExecutionContext context)
@@ -50,7 +51,7 @@ private static IEnumerable<AsyncMethodGrouping> GetMethodsGroupedBySyntaxTree(Ge
                 syntaxReceiver,
                 GetAsyncOverloadAttributeSymbol(context));
 
-        private static string GenerateOverloads(AsyncMethodGrouping grouping, GenerationOptions options)
+        private static string GenerateOverloads(AsyncMethodGrouping grouping, GenerationOptions options, GeneratorExecutionContext context, INamedTypeSymbol attributeSymbol)
         {
             var usings = grouping.SyntaxTree.GetRoot() is CompilationUnitSyntax compilationUnit
                 ? compilationUnit.Usings.ToString()
@@ -65,7 +66,10 @@ private static string GenerateOverloads(AsyncMethodGrouping grouping, Generation
             overloads.AppendLine("    {");
 
             foreach (var method in grouping.Methods)
-                overloads.AppendLine(GenerateOverload(method, options));
+            {
+                var model = context.Compilation.GetSemanticModel(method.Syntax.SyntaxTree);
+                overloads.AppendLine(GenerateOverload(method, options, model, attributeSymbol));
+            }
 
             overloads.AppendLine("    }");
             overloads.AppendLine("}");
@@ -73,8 +77,22 @@ private static string GenerateOverloads(AsyncMethodGrouping grouping, Generation
             return overloads.ToString();
         }
 
-        private static string GenerateOverload(AsyncMethod method, GenerationOptions options)
-            => MethodDeclaration(method.Syntax.ReturnType, GetMethodName(method.Symbol, options))
+        //var allLeadingTrivia = method.Syntax.GetLeadingTrivia();
+        //var allLeadingTriviaStructure = method.Syntax.GetLeadingTrivia().Select(t => t.GetStructure());
+        //var leadingTrivia = method.Syntax.GetLeadingTrivia().Where(t => !t.IsKind(SyntaxKind.DisabledTextTrivia) && t.GetStructure() is not DirectiveTriviaSyntax);
+
+        private static string GenerateOverload(AsyncMethod method, GenerationOptions options, SemanticModel model, INamedTypeSymbol attributeSymbol)
+        {
+            var attributeListsWithGenerateAsyncOverloadRemoved = SyntaxFactory.List(method.Syntax.AttributeLists
+                .Select(list => AttributeList(SeparatedList(
+                        (from a in list.Attributes
+                         let am = model.GetSymbolInfo(a.Name).Symbol?.ContainingType
+                         where !SymbolEqualityComparer.Default.Equals(am, attributeSymbol)
+                         select a))))
+                .Where(list => list.Attributes.Count > 0));
+
+            return MethodDeclaration(method.Syntax.ReturnType, GetMethodName(method.Symbol, options))
+                .WithAttributeLists(attributeListsWithGenerateAsyncOverloadRemoved)
                 .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword)))
                 .WithTypeParameterList(method.Syntax.TypeParameterList)
                 .WithParameterList(method.Syntax.ParameterList)
@@ -87,9 +105,10 @@ private static string GenerateOverload(AsyncMethod method, GenerationOptions opt
                                 method.Syntax.ParameterList.Parameters
                                     .Select(p => Argument(IdentifierName(p.Identifier))))))))
                 .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))
-                .WithLeadingTrivia(method.Syntax.GetLeadingTrivia().Where(t => t.GetStructure() is not DirectiveTriviaSyntax))
+                .WithLeadingTrivia(method.Syntax.GetLeadingTrivia().Where(t => !t.IsKind(SyntaxKind.DisabledTextTrivia) && t.GetStructure() is not DirectiveTriviaSyntax))
                 .NormalizeWhitespace()
                 .ToFullString();
+        }
 
         private static INamedTypeSymbol GetAsyncOverloadAttributeSymbol(GeneratorExecutionContext context)
             => context.Compilation.GetTypeByMetadataName("System.Linq.GenerateAsyncOverloadAttribute") ?? throw new InvalidOperationException();
diff --git a/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json b/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json
new file mode 100644
index 000000000..e1a11eac9
--- /dev/null
+++ b/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json
@@ -0,0 +1,11 @@
+{
+  "profiles": {
+    "System.Linq.Async.SourceGenerator": {
+      "commandName": "Project"
+    },
+    "Profile 1": {
+      "commandName": "DebugRoslynComponent",
+      "targetProject": "..\\refs\\System.Linq.Async\\System.Linq.Async.csproj"
+    }
+  }
+}
\ No newline at end of file
diff --git a/Ix.NET/Source/System.Linq.Async.SourceGenerator/System.Linq.Async.SourceGenerator.csproj b/Ix.NET/Source/System.Linq.Async.SourceGenerator/System.Linq.Async.SourceGenerator.csproj
index 8604e8dc6..51925c090 100644
--- a/Ix.NET/Source/System.Linq.Async.SourceGenerator/System.Linq.Async.SourceGenerator.csproj
+++ b/Ix.NET/Source/System.Linq.Async.SourceGenerator/System.Linq.Async.SourceGenerator.csproj
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <IsRoslynComponent>true</IsRoslynComponent>
     <LangVersion>9.0</LangVersion>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs
index 4bdf37667..045300b90 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncIterator.Opt.cs
@@ -8,7 +8,6 @@
 
 namespace System.Linq
 {
-#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     internal partial class AsyncIteratorBase<TSource>
     {
         public virtual IAsyncEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
@@ -45,5 +44,4 @@ public virtual IAsyncEnumerable<TSource> Where(Func<TSource, CancellationToken,
         }
 #endif
     }
-#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs
index f50884996..14e6751ca 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/IOrderedAsyncEnumerable.cs
@@ -46,6 +46,6 @@ public interface IOrderedAsyncEnumerable<out TElement> : IAsyncEnumerable<TEleme
         /// <returns>An ordered async-enumerable whose elements are sorted according to a key.</returns>
         IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey>? comparer, bool descending);
 #endif
-#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs
index 0ee37871c..a6c3c11f8 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs
@@ -12,7 +12,7 @@ public static partial class AsyncEnumerable
     {
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.aggregateasync?view=net-9.0-pp#system-linq-asyncenumerable-aggregateasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-0-0))-system-threading-cancellationtoken)
-        // public static ValueTask<TSource> AggregateAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, TSource> func, CancellationToken cancellationToken = default);
+
 
         /// <summary>
         /// Applies an accumulator function over an async-enumerable sequence, returning the result of the aggregation as a single element in the result sequence.
@@ -68,7 +68,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
-        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
+        [Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwaitAsync now exists as overloads of AggregateAsync.")]
         private static ValueTask<TSource> AggregateAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -108,7 +108,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         //  this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default) { }
 
         [GenerateAsyncOverload]
-        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
+        [Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwaitWithCancellationAsync functionality now exists as overloads of AggregateAsync.")]
         private static ValueTask<TSource> AggregateAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, CancellationToken, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -193,7 +193,7 @@ static async ValueTask<TAccumulate> Core(IAsyncEnumerable<TSource> source, TAccu
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="accumulator"/> is <see langword="null"/>.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
-        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
+        [Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwaitAsync functionality now exists as overloads of AggregateAsync.")]
         private static ValueTask<TAccumulate> AggregateAwaitAsyncCore<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -218,7 +218,7 @@ static async ValueTask<TAccumulate> Core(IAsyncEnumerable<TSource> source, TAccu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
-        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
+        [Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwaitWithCancellationAsync functionality now exists as overloads of AggregateAsync.")]
         private static ValueTask<TAccumulate> AggregateAwaitWithCancellationAsyncCore<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -301,7 +301,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, TAccumula
         /// <returns>A ValueTask containing the value obtained by applying the result selector to the final accumulator value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="accumulator"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ...Await... and ...WithCancellation... functionality now exists as overloads of Aggregate.")]
+        [Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwaitAsync functionality now exists as overloads of AggregateAsync.")]
         private static ValueTask<TResult> AggregateAwaitAsyncCore<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -328,6 +328,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, TAccumula
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwaitWithCancellationAsync functionality now exists as overloads of AggregateAsync.")]
         private static ValueTask<TResult> AggregateAwaitWithCancellationAsyncCore<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/All.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/All.cs
index f1b40e7b7..0ca91882a 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/All.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/All.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.allasync?view=net-9.0-pp#system-linq-asyncenumerable-allasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Determines whether all elements of an async-enumerable sequence satisfy a condition.
         /// </summary>
@@ -42,6 +45,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
                 return true;
             }
         }
+#endif
 
         /// <summary>
         /// Determines whether all elements in an async-enumerable sequence satisfy a condition.
@@ -54,6 +58,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AllAwaitAsync functionality now exists as overloads of All.")]
         private static ValueTask<bool> AllAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -79,6 +84,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AllAwaitWithCancellationAsync functionality now exists as overloads of AllAsync.")]
         internal static ValueTask<bool> AllAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs
index 68138f4ca..e3fe100c0 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs
@@ -10,6 +10,8 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.anyasync?view=net-9.0-pp#system-linq-asyncenumerable-anyasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
         /// <summary>
         /// Determines whether an async-enumerable sequence contains any elements.
         /// </summary>
@@ -34,6 +36,8 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Cancellation
             }
         }
 
+        //https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.anyasync?view=net-9.0-pp#system-linq-asyncenumerable-anyasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Determines whether any element of an async-enumerable sequence satisfies a condition.
         /// </summary>
@@ -66,6 +70,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
                 return false;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Determines whether any element in an async-enumerable sequence satisfies a condition.
@@ -78,6 +83,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AnyAwaitAsyncCore functionality now exists as overloads of AnyAsync.")]
         private static ValueTask<bool> AnyAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -103,6 +109,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AnyAwaitWithCancellationAsync functionality now exists as overloads of AnyAsync.")]
         internal static ValueTask<bool> AnyAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs
index 8b146d68c..d533b595d 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs
@@ -12,6 +12,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.append?view=net-9.0-pp
+
         /// <summary>
         /// Append a value to an async-enumerable sequence.
         /// </summary>
@@ -33,6 +36,8 @@ public static IAsyncEnumerable<TSource> Append<TSource>(this IAsyncEnumerable<TS
             return new AppendPrepend1AsyncIterator<TSource>(source, element, appending: true);
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.prepend?view=net-9.0-pp
+
         /// <summary>
         /// Prepend a value to an async-enumerable sequence.
         /// </summary>
@@ -53,6 +58,7 @@ public static IAsyncEnumerable<TSource> Prepend<TSource>(this IAsyncEnumerable<T
 
             return new AppendPrepend1AsyncIterator<TSource>(source, element, appending: false);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         private abstract class AppendPrependAsyncIterator<TSource> : AsyncIterator<TSource>, IAsyncIListProvider<TSource>
         {
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs
index 75f9459cc..5525b642b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs
@@ -10,6 +10,17 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // The next two methods are replaced by a single method in System.Linq.AsyncEnumerable:
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.groupby?view=net-9.0-pp#system-linq-asyncenumerable-groupby-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-iequalitycomparer((-1)))
+        // It has a different signature from both:
+        //  Returns an IAsyncEnumerable<IGrouping<TKey, TElement>>, which is not the same as IAsyncGrouping<TKey, TElement>
+        //  Supplies a default value of null for the comparer
+        // That second difference is why there's only the one overload.
+        // The first difference seems large: IAsyncGrouping returns each group as an IAsyncEnumerable. In practice,
+        // the grouping operators enumerate the source to completion before returning anything so in practice this
+        // async capability is not used, and just complicates things for the consumer.
+
         /// <summary>
         /// Groups the elements of an async-enumerable sequence according to a specified key selector function.
         /// </summary>
@@ -34,6 +45,7 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, T
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="comparer"/> is null.</exception>
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Groups the elements of an async-enumerable sequence according to a specified key selector function.
@@ -45,6 +57,7 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, T
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null);
 
@@ -59,18 +72,31 @@ private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitCore<
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer);
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // The next two methods are replaced by a single method in System.Linq.AsyncEnumerable:
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.groupby?view=net-9.0-pp#system-linq-asyncenumerable-groupby-3(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-func((-0-2))-system-collections-generic-iequalitycomparer((-1)))
+        // It has a different signature from both:
+        //  Returns an IAsyncEnumerable<IGrouping<TKey, TElement>>, which is not the same as IAsyncGrouping<TKey, TElement>
+        //  Supplies a default value of null for the comparer
+        // That second difference is why there's only the one overload.
+        // The first difference seems large: IAsyncGrouping returns each group as an IAsyncEnumerable. In practice,
+        // the grouping operators enumerate the source to completion before returning anything so in practice this
+        // async capability is not used, and just complicates things for the consumer.
 
         /// <summary>
         /// Groups the elements of an async-enumerable sequence and selects the resulting elements by using a specified function.
@@ -100,6 +126,7 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="comparer"/> is null.</exception>
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Groups the elements of an async-enumerable sequence and selects the resulting elements by using a specified function.
@@ -113,6 +140,7 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null);
 
@@ -129,24 +157,30 @@ private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitCore
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellationCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellationCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.groupby?view=net-9.0-pp#system-linq-asyncenumerable-groupby-3(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-func((-1-system-collections-generic-ienumerable((-0))-2))-system-collections-generic-iequalitycomparer((-1)))
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector) =>
             new GroupedResultAsyncEnumerable<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerable<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Groups the elements of an async-enumerable sequence according to a specified key selector function, and then applies a result selector function to each group.
@@ -160,6 +194,7 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAs
         /// <returns>An async-enumerable sequence of results obtained by invoking and awaiting the result-selector function on each group.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
@@ -176,24 +211,32 @@ private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TResult
         /// <returns>An async-enumerable sequence of results obtained by invoking and awaiting the result-selector function on each group.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="resultSelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // This covers the next two
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.groupby?view=net-9.0-pp#system-linq-asyncenumerable-groupby-4(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((-1))))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((-2))))-system-func((-1-system-collections-generic-ienumerable((-2))-system-threading-cancellationtoken-system-threading-tasks-valuetask((-3))))-system-collections-generic-iequalitycomparer((-1)))
+
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, TResult> resultSelector) =>
             new GroupedResultAsyncEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Groups the elements of an async-enumerable sequence according to a specified key-selector function, applies an element selector to each element of each group, then applies a result selector to each transformed group.
@@ -209,6 +252,7 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult
         /// <returns>An async-enumerable sequence of results obtained by invoking the result selector function on each group and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
@@ -227,15 +271,18 @@ private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TElemen
         /// <returns>An async-enumerable sequence of results obtained by invoking the result selector function on each group and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="resultSelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 #endif
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs
index 4ec45dca0..218bbb764 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs
@@ -10,7 +10,6 @@
 
 namespace System.Linq.Internal
 {
-#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     /// Adapted from System.Linq.Grouping from .NET Framework
     /// Source: https://github.com/dotnet/corefx/blob/b90532bc97b07234a7d18073819d019645285f1c/src/System.Linq/src/System/Linq/Grouping.cs#L64
     internal class Grouping<TKey, TElement> : IGrouping<TKey, TElement>, IList<TElement>, IAsyncGrouping<TKey, TElement>
@@ -107,5 +106,4 @@ IAsyncEnumerator<TElement> IAsyncEnumerable<TElement>.GetAsyncEnumerator(Cancell
             return this.ToAsyncEnumerable().GetAsyncEnumerator(cancellationToken);
         }
     }
-#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs
index 0a468e528..854f1583d 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs
@@ -11,7 +11,6 @@
 
 namespace System.Linq.Internal
 {
-#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     internal class Lookup<TKey, TElement> : ILookup<TKey, TElement>, IAsyncIListProvider<IAsyncGrouping<TKey, TElement>>
     {
         private readonly IEqualityComparer<TKey> _comparer;
@@ -648,5 +647,4 @@ ValueTask<IAsyncGrouping<TKey, TElement>[]> IAsyncIListProvider<IAsyncGrouping<T
             return new ValueTask<IAsyncGrouping<TKey, TElement>[]>(array);
         }
     }
-#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs
index ecb1b1207..5d16689bd 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
@@ -8,6 +8,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     public static partial class AsyncEnumerable
     {
         /// <summary>
@@ -326,4 +327,5 @@ private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancell
         }
 #endif
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs
index bcd1b9ffc..ff8383c30 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.select?view=net-9.0-pp#system-linq-asyncenumerable-select-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1)))
+
         /// <summary>
         /// Projects each element of an async-enumerable sequence into a new form.
         /// </summary>
@@ -33,6 +36,7 @@ public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnum
                 _ => new SelectEnumerableAsyncIterator<TSource, TResult>(source, selector),
             };
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Projects each element of an async-enumerable sequence into a new form by incorporating the element's index.
@@ -78,6 +82,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence whose elements are the result of invoking the transform function on each element of the source sequence and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwait and AggregateAwaitWithCancellationAsync functionality now exists as overloads of Aggregate.")]
         private static IAsyncEnumerable<TResult> SelectAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs
index 483f45b0b..b3d1b69e0 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.cs
@@ -9,6 +9,7 @@
 
 namespace System.Linq
 {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     public static partial class AsyncEnumerable
     {
         /// <summary>
@@ -301,4 +302,5 @@ public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancella
             bool ICollection<T>.IsReadOnly => _source.IsReadOnly;
         }
     }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 }
diff --git a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
index 7c46349cd..24ad29b46 100644
--- a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
+++ b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
@@ -6,7 +6,7 @@
     <Description>LINQ Standard Query Operators used to express queries over asynchronous enumerable sequences.</Description>
     <AssemblyTitle>System.Linq.Async</AssemblyTitle>
     <Authors>Microsoft</Authors>
-    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net10.0</TargetFrameworks>
     <PackageTags>Enumerable;Asynchronous;LINQ</PackageTags>
     <AssemblyName>System.Linq.Async</AssemblyName>
   </PropertyGroup>
@@ -14,8 +14,10 @@
   <PropertyGroup>
       <!--
     IDE0301 uses collection expressions in places where they don't necessarily have the same effect, which we want to avoid in case of possible compatibility issues.
-    IDE0305 wants to turn things like list.ToArray into [..list], which we don't find to be an improvement in readability. -->
-    <NoWarn>$(NoWarn);IDE0301;IDE0305</NoWarn>
+    IDE0305 wants to turn things like list.ToArray into [..list], which we don't find to be an improvement in readability.
+    CS0618: Type or member is obsolete - this whole library is essentially obsolete, so internal use of obsolete features is OK and widespread.
+    -->
+    <NoWarn>$(NoWarn);IDE0301;IDE0305;CS0618</NoWarn>
 
   </PropertyGroup>
   <ItemGroup>

From 638be50b82deffd588a5d108cdecb593183c0352 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 08:28:38 +0100
Subject: [PATCH 03/10] Handle AverageAsync migration

This is more complex than anything else so far for a couple of reasons.

First this uses T4 templates to generate code which in turn contains the [GenerateAsyncOverload] attribute, so we have two levels of code generation.

Second, System.Linq.AsyncEnumerable has elected not to implement all of the functionality available in System.Linq.Async (e.g. overloads taking selector callbacks).
---
 .../adr/0002-System-Linq-Async-In-Net10.md    |    6 +
 .../System.Interactive.Async.csproj           |   23 +
 .../Linq/Operators/AsAsyncEnumerable.cs       |   26 +
 .../Linq/Operators/Average.Generated.cs       | 1424 +++++++++++++++++
 .../Linq/Operators/Average.Generated.tt       |  318 ++++
 .../AsyncOverloadsGenerator.cs                |   10 +-
 .../Properties/launchSettings.json            |    9 +-
 .../System.Linq.Async.Tests.csproj            |   17 +-
 .../System.Linq.Async.csproj                  |   17 +-
 .../Linq/Operators/AsAsyncEnumerable.cs       |    9 +-
 .../Linq/Operators/Average.Generated.cs       |   53 +-
 .../Linq/Operators/Average.Generated.tt       |   19 +-
 12 files changed, 1905 insertions(+), 26 deletions(-)
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt

diff --git a/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md b/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md
index aae4be861..1e33bb2f4 100644
--- a/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md
+++ b/Ix.NET/Documentation/adr/0002-System-Linq-Async-In-Net10.md
@@ -41,4 +41,10 @@ The next `System.Linq.Async` release will:
 5. TBD `IAsyncIListProvider` relocate?
 6. continue to provide the full API in the `lib` assemblies to provide binary compatibility
 
+Note that not all of the XxxAwaitAsync and XxxAwaitWithCancellationAsync are handled the same way. In some cases, these now have replacements. E.g. System.Linq.AsyncEnumerable replaces AggregateAwaitAsync with an overload of AggregateAsync. So System.Linq.Async's ref assembly continues to make AggregateAwaitAsync available but marks it as Obsolete, telling you to use AggregateAsync instead. But there are some methods for which no replacement exists. We move these into System.Interactive.Async, because that's where `IAsyncEnumerable<T>` features that have no equivalents in the .NET runtime libraries live. E.g., although `System.Linq.AsyncEnumerable` defines `AverageAsync`, it does not offer the same range of functionality as `System.Linq.Async` previously did: overloads taking selectors (both sync and async). These methods become hidden in `System.Linq.Async` (available only for binary compatibility) and they have moved to `AsyncEnumerableEx` in `System.Interactive.Async`, and `System.Linq.Async` now adds a transitive reference to `System.Interactive.Async` in order to ensure continued source compatibility until such time as people update their NuGet references.
 
+combinations:
+
+* Method hidden in ref, available in `System.Linq.AsyncEnumerable`
+* Method hidden in ref, available in `System.Interactive.Async`
+* Method visible but marked as `Obsolete`
\ No newline at end of file
diff --git a/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj b/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj
index a092c2c3a..2270a5232 100644
--- a/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj
+++ b/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj
@@ -28,4 +28,27 @@
     <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\System.Linq.Async.SourceGenerator\System.Linq.Async.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" Private="false" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="System\Linq\Operators\Average.Generated.cs">
+      <DependentUpon>Average.Generated.tt</DependentUpon>
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="System\Linq\Operators\Average.Generated.tt">
+      <LastGenOutput>Average.Generated.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
 </Project>
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs
new file mode 100644
index 000000000..b40187c52
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+using System.Collections.Generic;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerableEx
+    {
+        // NB: Synchronous LINQ to Objects doesn't hide the implementation of the source either.
+
+        // Note: this was previous in System.Linq.Async, but since .NET 10.0's System.Linq.AsyncEnumerable chose not to
+        // implement it (even though Enumerable.AsEnumerable exists), we moved it into System.Interactive.Async so that
+        // it remains available even after developers remove their dependency on the deprecated System.Linq.Async.
+
+        /// <summary>
+        /// Hides the identity of an async-enumerable sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence whose identity to hide.</param>
+        /// <returns>An async-enumerable sequence that hides the identity of the source sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+        public static IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this IAsyncEnumerable<TSource> source) => source;
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs
new file mode 100644
index 000000000..a8cfe864a
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs
@@ -0,0 +1,1424 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerableEx
+    {
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    long sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
+                        }
+                    }
+
+                    return (double)sum / count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    long sum = await selector(e.Current).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return (double)sum / count;
+                }
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    long sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return (double)sum / count;
+                }
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    long sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
+                        }
+                    }
+
+                    return (double)sum / count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    long sum = await selector(e.Current).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return (double)sum / count;
+                }
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    long sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return (double)sum / count;
+                }
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<float> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    double sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
+                        }
+                    }
+
+                    return (float)(sum / count);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<float> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    double sum = await selector(e.Current).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return (float)(sum / count);
+                }
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<float> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    double sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return (float)(sum / count);
+                }
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    double sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
+                        }
+                    }
+
+                    return sum / count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    double sum = await selector(e.Current).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return sum / count;
+                }
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    double sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return sum / count;
+                }
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="decimal" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<decimal> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    decimal sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
+                        }
+                    }
+
+                    return sum / count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    decimal sum = await selector(e.Current).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return sum / count;
+                }
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    decimal sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return sum / count;
+                }
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Int}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = selector(e.Current);
+                        if (v.HasValue)
+                        {
+                            long sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = selector(e.Current);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (double)sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            long sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (double)sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            long sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (double)sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Long}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = selector(e.Current);
+                        if (v.HasValue)
+                        {
+                            long sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = selector(e.Current);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (double)sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            long sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (double)sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            long sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (double)sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Float}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<float?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = selector(e.Current);
+                        if (v.HasValue)
+                        {
+                            double sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = selector(e.Current);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (float)(sum / count);
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<float?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            double sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (float)(sum / count);
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<float?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            double sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return (float)(sum / count);
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Double}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = selector(e.Current);
+                        if (v.HasValue)
+                        {
+                            double sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = selector(e.Current);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            double sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            double sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+#endif
+
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<decimal?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = selector(e.Current);
+                        if (v.HasValue)
+                        {
+                            decimal sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = selector(e.Current);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            decimal sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken)
+            {
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            decimal sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return sum / count;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+#endif
+
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt
new file mode 100644
index 000000000..499c04e97
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt
@@ -0,0 +1,318 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+<#
+// Although .NET 10.0's System.Linq.AsyncEnumerable defines AverageAsync, it is missing some features that were previously defined in System.Linq.Async:
+//  Overloads of AverageAsync accepting a selector function (e.g. xs.AverageAsync(x => x.Value))
+//  The AverageAwaitAsync variants accepting an async selector function returning a ValueTask
+//  The AverageAwaitWithCancellationAsync variant where an async selector function accepts a CancellationToken
+// Since we are deprecating System.Linq.Async, these methods are now available there only in the runtime (lib) assemblies and not the
+// ref assemblies. So they are available for binary backwards compatibility, but are not visible during compilation. This is necessary
+// to ensure that code now gets the .NET 10 implementations of AverageAsync where available. But we want to enable code that was using
+// the functionality that .NET 10 did not replicate to be able to continue to work after removing the reference to System.Linq.Async.
+// So we've moved the relevant functionality back into System.Interactive.Async because that has always been the home of LINQ-like
+// features for IAsyncEnumerable<T> that aren't part of the core LINQ functionality.
+#>
+    public static partial class AsyncEnumerableEx
+    {
+<#
+var os = new[]
+{
+    new { type = "int", res = "double", sum = "long" },
+    new { type = "long", res = "double", sum = "long" },
+    new { type = "float", res = "float", sum = "double" },
+    new { type = "double", res = "double", sum = "double" },
+    new { type = "decimal", res = "decimal", sum = "decimal" },
+    new { type = "int?", res = "double?", sum = "long" },
+    new { type = "long?", res = "double?", sum = "long" },
+    new { type = "float?", res = "float?", sum = "double" },
+    new { type = "double?", res = "double?", sum = "double" },
+    new { type = "decimal?", res = "decimal?", sum = "decimal" },
+};
+
+foreach (var o in os)
+{
+    var isNullable = o.type.EndsWith("?");
+    var t = o.type.TrimEnd('?');
+
+    string res = "";
+
+    if (t == "int" || t == "long")
+        res = "(double)sum / count";
+    else if (t == "double" || t == "decimal")
+        res = "sum / count";
+    else if (t == "float")
+        res = "(float)(sum / count)";
+
+    var typeStr = o.type;
+    if (isNullable) {
+        typeStr = "Nullable{" + o.type.Substring(0, 1).ToUpper() + o.type.Substring(1, o.type.Length - 2) + "}";
+    }
+#>
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="<#=typeStr#>" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<<#=o.res#>> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<<#=o.res#>> Core(IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector, CancellationToken cancellationToken)
+            {
+<#
+if (isNullable)
+{
+#>
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = selector(e.Current);
+                        if (v.HasValue)
+                        {
+                            <#=o.sum#> sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = selector(e.Current);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return <#=res#>;
+                        }
+                    }
+                }
+
+                return null;
+<#
+}
+else
+{
+#>
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    <#=o.sum#> sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
+                        }
+                    }
+
+                    return <#=res#>;
+                }
+<#
+}
+#>
+            }
+        }
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<<#=o.res#>> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<<#=o.res#>> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken)
+            {
+<#
+if (isNullable)
+{
+#>
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            <#=o.sum#> sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return <#=res#>;
+                        }
+                    }
+                }
+
+                return null;
+<#
+}
+else
+{
+#>
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    <#=o.sum#> sum = await selector(e.Current).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return <#=res#>;
+                }
+<#
+}
+#>
+            }
+        }
+
+#if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+        private static ValueTask<<#=o.res#>> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+            if (selector == null)
+                throw Error.ArgumentNull(nameof(selector));
+
+            return Core(source, selector, cancellationToken);
+
+            static async ValueTask<<#=o.res#>> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken)
+            {
+<#
+if (isNullable)
+{
+#>
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        if (v.HasValue)
+                        {
+                            <#=o.sum#> sum = v.GetValueOrDefault();
+                            long count = 1;
+                            checked
+                            {
+                                while (await e.MoveNextAsync())
+                                {
+                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    if (v.HasValue)
+                                    {
+                                        sum += v.GetValueOrDefault();
+                                        ++count;
+                                    }
+                                }
+                            }
+
+                            return <#=res#>;
+                        }
+                    }
+                }
+
+                return null;
+<#
+}
+else
+{
+#>
+                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
+                {
+                    if (!await e.MoveNextAsync())
+                    {
+                        throw Error.NoElements();
+                    }
+
+                    <#=o.sum#> sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                            ++count;
+                        }
+                    }
+
+                    return <#=res#>;
+                }
+<#
+}
+#>
+            }
+        }
+#endif
+
+<#
+}
+#>
+    }
+}
diff --git a/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs b/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
index 2856ee306..6300d4b99 100644
--- a/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
+++ b/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
@@ -57,12 +57,20 @@ private static string GenerateOverloads(AsyncMethodGrouping grouping, Generation
                 ? compilationUnit.Usings.ToString()
                 : string.Empty;
 
+            // This source generator gets used not just in System.Linq.Async, but also for code that has migrated from
+            // System.Linq.Async to System.Interactive.Async. (E.g., we define overloads of AverageAsync that accept
+            // selector callbacks. The .NET runtime library implementation offers no equivalents. We want to continue
+            // to offer these even though we're decprecating System.Linq.Async, so they migrate into
+            // System.Interactive.Async.) In those cases, the containing type is typically AsyncEnumerableEx,
+            // but in System.Linq.Async it is AsyncEnumerable. So we need to discover the containing type name.
+            var containingTypeName = grouping.Methods.First().Symbol.ContainingType.Name;
+
             var overloads = new StringBuilder();
             overloads.AppendLine("#nullable enable");
             overloads.AppendLine(usings);
             overloads.AppendLine("namespace System.Linq");
             overloads.AppendLine("{");
-            overloads.AppendLine("    partial class AsyncEnumerable");
+            overloads.AppendLine($"    partial class {containingTypeName}");
             overloads.AppendLine("    {");
 
             foreach (var method in grouping.Methods)
diff --git a/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json b/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json
index e1a11eac9..ecfa363e7 100644
--- a/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json
+++ b/Ix.NET/Source/System.Linq.Async.SourceGenerator/Properties/launchSettings.json
@@ -1,11 +1,12 @@
 {
   "profiles": {
-    "System.Linq.Async.SourceGenerator": {
-      "commandName": "Project"
+    "System.Linq.Async": {
+      "commandName": "DebugRoslynComponent",
+      "targetProject": "..\\System.Linq.Async\\System.Linq.Async.csproj"
     },
-    "Profile 1": {
+    "System.Interactive.Async": {
       "commandName": "DebugRoslynComponent",
-      "targetProject": "..\\refs\\System.Linq.Async\\System.Linq.Async.csproj"
+      "targetProject": "..\\System.Interactive.Async\\System.Interactive.Async.csproj"
     }
   }
 }
\ No newline at end of file
diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj b/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj
index 2c4e2a59d..23e5b8294 100644
--- a/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj
+++ b/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj
@@ -41,6 +41,20 @@
   </ItemGroup>
 
   <ItemGroup>
+    <!--
+    System.Linq.Async brings in a transitive dependency on System.Interactive.Async, because in normal use,
+    the methods in System.Linq.Async that are not in System.Linq.AsyncEnumerable are now used via their new
+    home in System.Interactive.Async. However, there's a complication: for binary compatibility we retain these
+    methods in the System.Linq.Async runtime assemblies (lib), removing them from the ref assemblies so that
+    they are invisible at compile time. However, that trick works only for references via the NuGet package; this
+    test project has a direct project reference to System.Linq.Async meaning that it can see all the methods that
+    are deliberately hidden at compile time in normal use. This particular test project actually wants to test
+    those hidden methods (because we still need to ensure that code relying on the binary compatibility will work).
+    So we set an alias on System.Interactive.Async to avoid picking up its extension methods unless we explicitly want to.
+    -->
+    <ProjectReference Include="..\System.Interactive.Async\System.Interactive.Async.csproj">
+      <Aliases>SystemInteractiveAsync</Aliases>
+    </ProjectReference>
     <ProjectReference Include="..\System.Linq.Async\System.Linq.Async.csproj" />
   </ItemGroup>
 
@@ -50,8 +64,7 @@
   So although we get this references transitively (or automatically on .NET 10.0+) we need to put them explicitly here to set aliases.
   -->
   <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
-    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
-                      Aliases="SystemLinqAsyncEnumerable" />
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107" Aliases="SystemLinqAsyncEnumerable" />
   </ItemGroup>
 
   <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
diff --git a/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj
index c700c5b0f..37fe0f601 100644
--- a/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj
+++ b/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj
@@ -70,13 +70,22 @@
 
   <ItemGroup>
     <!--<PackageReference Condition="'$(TargetFramework)' == 'net48' or '$(TargetFramework)' == 'netstandard2.0' " Include="Microsoft.Bcl.AsyncInterfaces" Version="6.0.0" />-->
+
+    <!--
+    System.Linq.Async is being deprecated by System.Linq.AsyncEnumerable (part of .NET 10, but available to older runtimes via NuGet)
+    but System.Linq.AsyncEnumerable does not include all of System.Linq.Async's functionality. We're moving that functionality into
+    System.Interactive.Async, because that is the home of IAsyncEnumerable features that are LINQ-adjacent but not build into
+    the .NET runtime libraries.
+    By referencing System.Interactive.Async here, we make that functionality available to users of System.Linq.Async until such
+    time as they remove their reference to this library.
+    -->
+    <ProjectReference Include="..\System.Interactive.Async\System.Interactive.Async.csproj" Aliases="SystemInteractiveAsync" />
     <ProjectReference Include="..\System.Linq.Async.SourceGenerator\System.Linq.Async.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" Private="false" />
   </ItemGroup>
 
 
   <ItemGroup Condition="'$(TargetFramework)' != 'net10.0'">
-    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107"
-                      Aliases="SystemLinqAsyncEnumerable" />
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-rc.1.25451.107" Aliases="SystemLinqAsyncEnumerable" />
   </ItemGroup>
 
   <Target Name="_SetAliasOnBuiltInSystemLinqAsyncEnumerable" BeforeTargets="ResolveAssemblyReferences">
@@ -148,4 +157,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
 </Project>
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AsAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AsAsyncEnumerable.cs
index ed1bc26d7..141663037 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AsAsyncEnumerable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AsAsyncEnumerable.cs
@@ -7,8 +7,14 @@
 namespace System.Linq
 {
     public static partial class AsyncEnumerable
-    {
         // NB: Synchronous LINQ to Objects doesn't hide the implementation of the source either.
+    {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // Note: this one isn't actually in the System.Linq.AsyncEnumerable package, so we've moved it
+        // to System.Interactive.Async because that's the home for LINQ-like implementations for
+        // IAsyncEnumerable<T> that aren't in the runtime libraries.
+        // It therefore remains available only for runtime binary compatibility, and is no longer
+        // visible in System.Linq.Async at compile time.
 
         /// <summary>
         /// Hides the identity of an async-enumerable sequence.
@@ -18,5 +24,6 @@ public static partial class AsyncEnumerable
         /// <returns>An async-enumerable sequence that hides the identity of the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
         public static IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this IAsyncEnumerable<TSource> source) => source;
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs
index abc41a542..0081d23b2 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs
@@ -10,6 +10,7 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int" /> values.
         /// </summary>
@@ -177,7 +178,9 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="long" /> values.
         /// </summary>
@@ -264,7 +267,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="long"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
@@ -345,7 +348,9 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="float" /> values.
         /// </summary>
@@ -432,7 +437,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="float"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
@@ -513,7 +518,9 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="double" /> values.
         /// </summary>
@@ -600,7 +607,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="double"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
@@ -681,7 +688,9 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="decimal" /> values.
         /// </summary>
@@ -768,7 +777,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="decimal"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
@@ -849,7 +858,9 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Int}" /> values.
         /// </summary>
@@ -952,14 +963,15 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Int}"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
         /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
         /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values, or <see langword="null"/> if the source sequence is empty.</returns>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
         private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
@@ -1048,7 +1060,9 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Long}" /> values.
         /// </summary>
@@ -1151,14 +1165,15 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Long}"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
         /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
         /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values, or <see langword="null"/> if the source sequence is empty.</returns>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
         private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
@@ -1247,7 +1262,9 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Float}" /> values.
         /// </summary>
@@ -1350,14 +1367,15 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Float}"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
         /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
         /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values, or <see langword="null"/> if the source sequence is empty.</returns>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
         private static ValueTask<float?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
@@ -1446,7 +1464,9 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Double}" /> values.
         /// </summary>
@@ -1549,14 +1569,15 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Double}"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
         /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
         /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values, or <see langword="null"/> if the source sequence is empty.</returns>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
         private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
@@ -1645,7 +1666,9 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
+#endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values.
         /// </summary>
@@ -1748,14 +1771,15 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Decimal}"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
         /// </summary>
         /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
         /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
         /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
         /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values, or <see langword="null"/> if the source sequence is empty.</returns>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
         private static ValueTask<decimal?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
@@ -1843,6 +1867,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
+#endif
 #endif
 
     }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt
index 9b53947e0..4d5a50834 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt
@@ -50,6 +50,7 @@ foreach (var o in os)
         typeStr = "Nullable{" + o.type.Substring(0, 1).ToUpper() + o.type.Substring(1, o.type.Length - 2) + "}";
     }
 #>
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="<#=typeStr#>" /> values.
         /// </summary>
@@ -215,7 +216,19 @@ else
             }
         }
 
-        internal static ValueTask<<#=o.res#>> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// </summary>
+        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
+        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
+        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [GenerateAsyncOverload]
+        private static ValueTask<<#=o.res#>> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -290,7 +303,8 @@ else
         }
 
 #if !NO_DEEP_CANCELLATION
-        internal static ValueTask<<#=o.res#>> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<<#=o.res#>> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -364,6 +378,7 @@ else
             }
         }
 #endif
+#endif
 
 <#
 }

From 8a96d97d04945767face4a5b8bc461069bf4ddbf Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 10:19:39 +0100
Subject: [PATCH 04/10] Update operators as far as Min

---
 .../System/Linq/Operators/Any.cs              |   2 +-
 .../System/Linq/Operators/Cast.cs             |   4 +
 .../System/Linq/Operators/Concat.cs           |   4 +
 .../System/Linq/Operators/Contains.cs         |   7 +
 .../System/Linq/Operators/Count.cs            |  15 ++
 .../System/Linq/Operators/DefaultIfEmpty.cs   |   2 +
 .../System/Linq/Operators/Distinct.cs         |   6 +
 .../System/Linq/Operators/ElementAt.cs        |   4 +
 .../Linq/Operators/ElementAtOrDefault.cs      |   4 +
 .../System/Linq/Operators/Empty.cs            |   4 +
 .../System/Linq/Operators/Except.cs           |   6 +
 .../System/Linq/Operators/First.cs            |  11 +
 .../System/Linq/Operators/FirstOrDefault.cs   |  10 +
 .../System/Linq/Operators/ForEach.cs          |   6 +
 .../System/Linq/Operators/GroupBy.cs          |  32 +--
 .../System/Linq/Operators/GroupJoin.cs        |   9 +
 .../System/Linq/Operators/Intersect.cs        |   5 +
 .../System/Linq/Operators/Join.cs             |  11 +
 .../System/Linq/Operators/Last.cs             |   9 +
 .../System/Linq/Operators/LastOrDefault.cs    |  10 +
 .../System/Linq/Operators/LongCount.cs        |   8 +
 .../System/Linq/Operators/Max.cs              |  15 ++
 .../System/Linq/Operators/Min.cs              |  15 ++
 .../System/Linq/Operators/MinMax.Generated.cs | 236 ++++++++++++------
 .../System/Linq/Operators/MinMax.Generated.tt |  25 +-
 25 files changed, 359 insertions(+), 101 deletions(-)

diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs
index e3fe100c0..14925d51b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs
@@ -83,7 +83,7 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, Func<TSource
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
-        [Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AnyAwaitAsyncCore functionality now exists as overloads of AnyAsync.")]
+        [Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AnyAwaitAsync functionality now exists as overloads of AnyAsync.")]
         private static ValueTask<bool> AnyAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Cast.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Cast.cs
index c52be4f98..3d54b9543 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Cast.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Cast.cs
@@ -13,6 +13,9 @@ public static partial class AsyncEnumerable
         // NB: This is a non-standard LINQ operator, because we don't have a non-generic IAsyncEnumerable.
         //     We're keeping it to enable `from T x in xs` binding in C#.
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.cast?view=net-9.0-pp
+
         /// <summary>
         /// Converts the elements of an async-enumerable sequence to the specified type.
         /// </summary>
@@ -40,5 +43,6 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<object> source, [Sy
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Concat.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Concat.cs
index aabfcd187..3733b3248 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Concat.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Concat.cs
@@ -11,6 +11,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.concat?view=net-9.0-pp
+
         /// <summary>
         /// Concatenates the second async-enumerable sequence to the first async-enumerable sequence upon successful termination of the first.
         /// </summary>
@@ -253,5 +256,6 @@ internal override ConcatAsyncIterator<TSource> Concat(IAsyncEnumerable<TSource>
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Contains.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Contains.cs
index 79779f120..1efc87304 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Contains.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Contains.cs
@@ -10,6 +10,12 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.containsasync?view=net-9.0-pp
+        //
+        // These two overloads are replaced by the single method above, which takes a comparer, but supplies a default
+        // value of null.
+
         /// <summary>
         /// Determines whether an async-enumerable sequence contains a specified element by using the default equality comparer.
         /// </summary>
@@ -78,5 +84,6 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> source, TSource valu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Count.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Count.cs
index ba839a4a4..43b43e913 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Count.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Count.cs
@@ -11,6 +11,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.countasync?view=net-9.0-pp#system-linq-asyncenumerable-countasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns an async-enumerable sequence containing an <see cref="int" /> that represents the total number of elements in an async-enumerable sequence.
         /// </summary>
@@ -50,6 +53,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, CancellationT
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.countasync?view=net-9.0-pp#system-linq-asyncenumerable-countasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns an async-enumerable sequence containing an <see cref="int" /> that represents how many elements in the specified async-enumerable sequence satisfy a condition.
         /// </summary>
@@ -87,6 +92,14 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
                 return count;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.countasync?view=net-9.0-pp#system-linq-asyncenumerable-countasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((system-boolean))))-system-threading-cancellationtoken)
+        // Two overloads here are replaced by a single method.
+        // System.Linq.AsyncEnumerable only supplies the async predicate form where the callback accepts a cancellation token, but
+        // the CountAwaitAsync version that does not take this does not add any additional functionality. Since developers will need
+        // to change their code in any case to move off these obsolete methods, it would not be particularly useful to add a
+        // non-cancellable async predicate overload in System.Interactive.Async.
 
         /// <summary>
         /// Counts the elements in an async-enumerable sequence that satisfy a condition.
@@ -98,6 +111,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         /// <returns>A ValueTask containing the number of elements in the sequence that satisfy the predicate.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the CountAwaitAsync functionality now exists as overloads of CountAsync.")]
         private static ValueTask<int> CountAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -127,6 +141,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the CountAwaitWithCancellationAsync functionality now exists as overloads of CountAsync.")]
         [GenerateAsyncOverload]
         private static ValueTask<int> CountAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs
index 8fe637ffa..a3aabbd51 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs
@@ -11,6 +11,7 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty.
         /// </summary>
@@ -136,5 +137,6 @@ public async ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken ca
                 return count == 0 ? 1 : count;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Distinct.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Distinct.cs
index ba7618c43..fda821da3 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Distinct.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Distinct.cs
@@ -10,6 +10,11 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.distinct?view=net-9.0-pp
+        // These two overloads are covered by a single method in System.Linq.AsyncEnumerable. Its only method
+        // takes a comparer, but specifies a default value of null.
+
         /// <summary>
         /// Returns an async-enumerable sequence that contains only distinct elements.
         /// </summary>
@@ -139,5 +144,6 @@ private Task<Set<TSource>> FillSetAsync(CancellationToken cancellationToken)
                 return AsyncEnumerableHelpers.ToSet(_source, _comparer, cancellationToken);
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAt.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAt.cs
index 97d4a2bca..9ccf32866 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAt.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAt.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.elementatasync?view=net-9.0-pp#system-linq-asyncenumerable-elementatasync-1(system-collections-generic-iasyncenumerable((-0))-system-int32-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the element at a specified index in a sequence.
         /// </summary>
@@ -66,5 +69,6 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, int index
                 throw Error.ArgumentOutOfRange(nameof(index));
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAtOrDefault.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAtOrDefault.cs
index c06a09af3..a22dd503f 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAtOrDefault.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ElementAtOrDefault.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.elementatordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-elementatordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-int32-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the element at a specified index in a sequence or a default value if the index is out of range.
         /// </summary>
@@ -65,5 +68,6 @@ public static partial class AsyncEnumerable
                 return default;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs
index 7509ef4dc..a6d975a4d 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.empty?view=net-9.0-pp
+
         /// <summary>
         /// Returns an empty async-enumerable sequence.
         /// </summary>
@@ -50,5 +53,6 @@ public IAsyncEnumerator<TValue> GetAsyncEnumerator(CancellationToken cancellatio
 
             public ValueTask DisposeAsync() => default;
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Except.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Except.cs
index 56c51c2f9..1bdfa7297 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Except.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Except.cs
@@ -10,6 +10,11 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.except?view=net-9.0-pp
+        //
+        // These two overloads are replaced by the single method above, which takes a comparer, but supplies a default
+        // value of null.
         /// <summary>
         /// Produces the set difference of two async-enumerable sequences by using the default equality comparer to compare values.
         /// </summary>
@@ -57,5 +62,6 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> first, IAs
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/First.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/First.cs
index 2bcfbb862..55df31271 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/First.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/First.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.firstasync?view=net-9.0-pp#system-linq-asyncenumerable-firstasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the first element of an async-enumerable sequence.
         /// </summary>
@@ -34,6 +37,8 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.firstasync?view=net-9.0-pp#system-linq-asyncenumerable-firstasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the first element of an async-enumerable sequence that satisfies the condition in the predicate.
         /// </summary>
@@ -60,6 +65,10 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return first.HasValue ? first.Value : throw Error.NoElements();
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.firstasync?view=net-9.0-pp#system-linq-asyncenumerable-firstasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((system-boolean))))-system-threading-cancellationtoken)
+        // That only offers the async-with-cancellation callback overload, but the simpler form offers no additional functionality.
 
         /// <summary>
         /// Returns the first element of an async-enumerable sequence that satisfies the condition in the predicate.
@@ -72,6 +81,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         /// <exception cref="InvalidOperationException">No element satisfies the condition in the predicate. -or- The source sequence is empty.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the FirstAwaitAsync functionality now exists as overloads of FirstAsync.")]
         private static ValueTask<TSource> FirstAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -91,6 +101,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the FirstAwaitWithCancellationAsync functionality now exists as overloads of FirstAsync.")]
         internal static ValueTask<TSource> FirstAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/FirstOrDefault.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/FirstOrDefault.cs
index d67b50ada..ea1a5345b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/FirstOrDefault.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/FirstOrDefault.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.firstordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-firstordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the first element of an async-enumerable sequence, or a default value if no such element exists.
         /// </summary>
@@ -33,6 +36,8 @@ public static partial class AsyncEnumerable
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.firstordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-firstordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the first element of an async-enumerable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
         /// </summary>
@@ -58,6 +63,9 @@ public static partial class AsyncEnumerable
                 return first.HasValue ? first.Value : default;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.firstordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-firstordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((system-boolean))))-system-threading-cancellationtoken)
 
         /// <summary>
         /// Returns the first element of an async-enumerable sequence that satisfies the condition in the predicate, or a default value if no element satisfies the condition in the predicate.
@@ -69,6 +77,7 @@ public static partial class AsyncEnumerable
         /// <returns>A ValueTask containing the first element in the sequence that satisfies the predicate, or a default value if no element satisfies the predicate.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the FirstOrDefaultAwaitAsync functionality now exists as overloads of FirstOrDefaultAsync.")]
         private static ValueTask<TSource?> FirstOrDefaultAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -88,6 +97,7 @@ public static partial class AsyncEnumerable
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the FirstOrDefaultAwaitWithCancellationAsync functionality now exists as overloads of FirstOrDefaultAsync.")]
         private static ValueTask<TSource?> FirstOrDefaultAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ForEach.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ForEach.cs
index 6e0302feb..6648c0f11 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ForEach.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ForEach.cs
@@ -27,6 +27,7 @@ public static partial class AsyncEnumerable
         /// <returns>Task that signals the termination of the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is null.</exception>
         /// <remarks>This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11.</remarks>
+        [Obsolete("Use the language support for async foreach instead.")]
         public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource> action, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -55,6 +56,7 @@ static async Task Core(IAsyncEnumerable<TSource> source, Action<TSource> action,
         /// <returns>Task that signals the termination of the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is null.</exception>
         /// <remarks>This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11.</remarks>
+        [Obsolete("Use the language support for async foreach instead.")]
         public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Action<TSource, int> action, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -85,6 +87,7 @@ static async Task Core(IAsyncEnumerable<TSource> source, Action<TSource, int> ac
         /// <returns>Task that signals the termination of the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use the language support for async foreach instead.")]
         private static Task ForEachAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, Task> action, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -105,6 +108,7 @@ static async Task Core(IAsyncEnumerable<TSource> source, Func<TSource, Task> act
 
         #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use the language support for async foreach instead.")]
         internal static Task ForEachAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, Task> action, CancellationToken cancellationToken)
         {
             if (source == null)
@@ -134,6 +138,7 @@ static async Task Core(IAsyncEnumerable<TSource> source, Func<TSource, Cancellat
         /// <returns>Task that signals the termination of the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use the language support for async foreach instead.")]
         private static Task ForEachAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, Task> action, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -156,6 +161,7 @@ static async Task Core(IAsyncEnumerable<TSource> source, Func<TSource, int, Task
 
         #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use the language support for async foreach instead.")]
         internal static Task ForEachAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, Task> action, CancellationToken cancellationToken)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs
index 5525b642b..cd684e72a 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs
@@ -57,7 +57,7 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, T
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null);
 
@@ -72,18 +72,18 @@ private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitCore<
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null);
 
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer);
 #endif
@@ -140,7 +140,7 @@ public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource,
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null);
 
@@ -157,18 +157,18 @@ private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitCore
         /// <returns>A sequence of async-enumerable groups, each of which corresponds to a unique key value, containing all elements that share that same key value.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellationCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null);
 
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellationCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 #endif
@@ -194,7 +194,7 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAs
         /// <returns>An async-enumerable sequence of results obtained by invoking and awaiting the result-selector function on each group.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
@@ -211,18 +211,18 @@ private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TResult
         /// <returns>An async-enumerable sequence of results obtained by invoking and awaiting the result-selector function on each group.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="resultSelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 #endif
@@ -252,7 +252,7 @@ public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult
         /// <returns>An async-enumerable sequence of results obtained by invoking the result selector function on each group and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
@@ -271,18 +271,18 @@ private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TElemen
         /// <returns>An async-enumerable sequence of results obtained by invoking the result selector function on each group and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="resultSelector"/> or <paramref name="comparer"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
-        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwait and GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
+        [Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupByAwaitWithCancellationAsync functionality now exists as overloads of GroupBy.")]
         private static IAsyncEnumerable<TResult> GroupByAwaitWithCancellationCore<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 #endif
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupJoin.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupJoin.cs
index e1182bc95..59af1f8e5 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupJoin.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupJoin.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.groupjoin?view=net-9.0-pp#system-linq-asyncenumerable-groupjoin-4(system-collections-generic-iasyncenumerable((-0))-system-collections-generic-iasyncenumerable((-1))-system-func((-0-2))-system-func((-1-2))-system-func((-0-system-collections-generic-ienumerable((-1))-3))-system-collections-generic-iequalitycomparer((-2)))
+        // The method above covers the next two overloads because it supplies a default null value for comparer.
+
         /// <summary>
         /// Correlates the elements of two async-enumerable sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.
         /// </summary>
@@ -75,12 +79,15 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TOuter> outer, IAsy
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
         private static IAsyncEnumerable<TResult> GroupJoinAwaitCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, ValueTask<TResult>> resultSelector) =>
             GroupJoinAwaitCore<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
         private static IAsyncEnumerable<TResult> GroupJoinAwaitCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             if (outer == null)
@@ -117,10 +124,12 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TOuter> outer, IAsy
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupJoinAwaitWithCancellation functionality now exists as overloads of GroupJoin.")]
         private static IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellationCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             GroupJoinAwaitWithCancellationCore<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the GroupJoinAwaitWithCancellation functionality now exists as overloads of GroupJoin.")]
         private static IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellationCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             if (outer == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Intersect.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Intersect.cs
index 00c76f0bb..1e5639e6c 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Intersect.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Intersect.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.intersect?view=net-9.0-pp
+        // The method above covers the next two overloads because it supplies a default null value for comparer.
+
         /// <summary>
         /// Produces the set intersection of two async-enumerable sequences by using the default equality comparer to compare values.
         /// </summary>
@@ -57,5 +61,6 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> first, IAs
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Join.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Join.cs
index e27723c9f..cb80f6cb0 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Join.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Join.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.join?view=net-9.0-pp#system-linq-asyncenumerable-join-4(system-collections-generic-iasyncenumerable((-0))-system-collections-generic-iasyncenumerable((-1))-system-func((-0-2))-system-func((-1-2))-system-func((-0-1-3))-system-collections-generic-iequalitycomparer((-2)))
+        // The method above covers the next two overloads because it supplies a default null value for comparer.
+
         /// <summary>
         /// Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
         /// </summary>
@@ -91,12 +95,17 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TOuter> outer, IAsy
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.join?view=net-9.0-pp#system-linq-asyncenumerable-join-4(system-collections-generic-iasyncenumerable((-0))-system-collections-generic-iasyncenumerable((-1))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((-2))))-system-func((-1-system-threading-cancellationtoken-system-threading-tasks-valuetask((-2))))-system-func((-0-1-system-threading-cancellationtoken-system-threading-tasks-valuetask((-3))))-system-collections-generic-iequalitycomparer((-2)))
 
         [GenerateAsyncOverload]
+        [Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the JoinAwait functionality now exists as overloads of Join.")]
         private static IAsyncEnumerable<TResult> JoinAwaitCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, ValueTask<TResult>> resultSelector) =>
             JoinAwaitCore<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the JoinAwait functionality now exists as overloads of Join.")]
         private static IAsyncEnumerable<TResult> JoinAwaitCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             if (outer == null)
@@ -149,10 +158,12 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TOuter> outer, IAsy
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the JoinAwaitWithCancellation functionality now exists as overloads of Join.")]
         private static IAsyncEnumerable<TResult> JoinAwaitWithCancellationCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, ValueTask<TResult>> resultSelector) =>
             JoinAwaitWithCancellationCore<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the JoinAwaitWithCancellation functionality now exists as overloads of Join.")]
         private static IAsyncEnumerable<TResult> JoinAwaitWithCancellationCore<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             if (outer == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Last.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Last.cs
index 0e77b193c..b4087d545 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Last.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Last.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.lastasync?view=net-9.0-pp#system-linq-asyncenumerable-lastasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the last element of an async-enumerable sequence.
         /// </summary>
@@ -34,6 +37,8 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.lastasync?view=net-9.0-pp#system-linq-asyncenumerable-lastasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the last element of an async-enumerable sequence that satisfies the condition in the predicate.
         /// </summary>
@@ -61,6 +66,8 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
         /// <summary>
         /// Returns the last element of an async-enumerable sequence that satisfies the condition in the predicate.
         /// </summary>
@@ -72,6 +79,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the LastAwaitAsync functionality now exists as overloads of LastAsync.")]
         private static ValueTask<TSource> LastAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -91,6 +99,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the LastAwaitWithCancellationAsync functionality now exists as overloads of LastAsync.")]
         private static ValueTask<TSource> LastAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LastOrDefault.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LastOrDefault.cs
index 9dae828c1..1a1c2fe53 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LastOrDefault.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LastOrDefault.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.lastordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-lastordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the last element of an async-enumerable sequence, or a default value if no such element exists.
         /// </summary>
@@ -33,6 +36,8 @@ public static partial class AsyncEnumerable
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.lastordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-lastordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the last element of an async-enumerable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
         /// </summary>
@@ -58,6 +63,9 @@ public static partial class AsyncEnumerable
                 return last.HasValue ? last.Value : default;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.lastordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-lastordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-threading-cancellationtoken-system-threading-tasks-valuetask((system-boolean))))-system-threading-cancellationtoken)
 
         /// <summary>
         /// Returns the last element of an async-enumerable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
@@ -69,6 +77,7 @@ public static partial class AsyncEnumerable
         /// <returns>ValueTask containing the last element in the async-enumerable sequence that satisfies the condition in the predicate, or a default value if no such element exists.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the LastOrDefaultAwaitAsync functionality now exists as overloads of LastOrDefaultAsync.")]
         private static ValueTask<TSource?> LastOrDefaultAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -88,6 +97,7 @@ public static partial class AsyncEnumerable
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the LastOrDefaultAwaitWithCancellationAsync functionality now exists as overloads of LastOrDefaultAsync.")]
         private static ValueTask<TSource?> LastOrDefaultAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LongCount.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LongCount.cs
index 463ce0ec0..e62e94e7f 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LongCount.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LongCount.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.longcountasync?view=net-9.0-pp#system-linq-asyncenumerable-longcountasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns an async-enumerable sequence containing an <see cref="long" /> that represents the total number of elements in an async-enumerable sequence.
         /// </summary>
@@ -43,6 +46,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Cancellation
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.longcountasync?view=net-9.0-pp#system-linq-asyncenumerable-longcountasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns an async-enumerable sequence containing an <see cref="long" /> that represents how many elements in the specified async-enumerable sequence satisfy a condition.
         /// </summary>
@@ -80,6 +85,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
                 return count;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Returns an async-enumerable sequence containing a <see cref="long" /> that represents the number of elements in the specified async-enumerable sequence that satisfy a condition.
@@ -92,6 +98,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the LongCountAwaitAsync functionality now exists as overloads of LongCountAsync.")]
         private static ValueTask<long> LongCountAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -122,6 +129,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the LongCountAwaitWithCancellationAsync functionality now exists as overloads of LongCountAsync.")]
         private static ValueTask<long> LongCountAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Max.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Max.cs
index 6190d7043..a15dbd393 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Max.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Max.cs
@@ -10,6 +10,16 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.maxasync?view=net-9.0-pp
+        // The method above has a slightly different signature: it takes a comparer. In cases where the cancellationToken
+        // has not been supplied, or has been passed by name, that method is source-compatible with this one.
+        // However, anyone calling this method with an unnamed cancellationToken argument will get an error because
+        // the comparer argument comes before the cancellationToken argument. There's not much we can do about
+        // this because if we continue to offer this method, it will result in ambiguous matches. The least bad
+        // option seems to be to hide this method, and anyone who was relying on it taking a positional
+        // cancellation token argument will need to deal with the compilation error.
+
         /// <summary>
         /// Returns the maximum element in an async-enumerable sequence.
         /// </summary>
@@ -95,6 +105,8 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes a transform function on each element of a sequence and returns the maximum value.
         /// </summary>
@@ -106,6 +118,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
         /// <returns>A ValueTask containing a single element with the value that corresponds to the maximum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by the MaxAsync overload that took a selector callback now exists as an overload of MaxByAsync.")]
         public static ValueTask<TResult> MaxAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -196,6 +209,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<TResult> MaxAwaitAsyncCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -277,6 +291,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<TResult> MaxAwaitWithCancellationAsyncCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Min.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Min.cs
index 5075c5e48..617d5070b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Min.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Min.cs
@@ -10,6 +10,16 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.minasync?view=net-9.0-pp
+        // The method above has a slightly different signature: it takes a comparer. In cases where the cancellationToken
+        // has not been supplied, or has been passed by name, that method is source-compatible with this one.
+        // However, anyone calling this method with an unnamed cancellationToken argument will get an error because
+        // the comparer argument comes before the cancellationToken argument. There's not much we can do about
+        // this because if we continue to offer this method, it will result in ambiguous matches. The least bad
+        // option seems to be to hide this method, and anyone who was relying on it taking a positional
+        // cancellation token argument will need to deal with the compilation error.
+
         /// <summary>
         /// Returns the minimum element in an async-enumerable sequence.
         /// </summary>
@@ -96,6 +106,8 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes a transform function on each element of a sequence and returns the minimum value.
         /// </summary>
@@ -107,6 +119,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
         /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by the MinAsync overload that took a selector callback now exists as an overload of MinByAsync.")]
         public static ValueTask<TResult> MinAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -198,6 +211,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<TResult> MinAwaitAsyncCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -279,6 +293,7 @@ static async ValueTask<TResult> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<TResult> MinAwaitWithCancellationAsyncCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs
index 47d0052d7..68f9e205b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs
@@ -10,6 +10,7 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="int" /> values.
         /// </summary>
@@ -50,6 +51,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<int> source, CancellationToken
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<int> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default)
         {
@@ -88,7 +90,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
         /// <summary>
-        /// Returns the maximum <see cref="int"/> value in an async-enumerable sequence.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="int"/> value.
         /// </summary>
         /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
         /// <param name="source">The source sequence.</param>
@@ -97,6 +99,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<int> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -135,6 +138,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<int> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -172,6 +176,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Int}" /> values.
         /// </summary>
@@ -251,6 +256,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<int?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
         {
@@ -328,7 +334,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
         /// <summary>
-        /// Returns the maximum <see cref="Nullable{Int}"/> value in an async-enumerable sequence.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Int}"/> value.
         /// </summary>
         /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
         /// <param name="source">The source sequence.</param>
@@ -337,6 +343,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<int?> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -414,6 +421,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<int?> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -490,6 +498,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="long" /> values.
         /// </summary>
@@ -530,6 +539,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<long> source, CancellationTok
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<long> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
         {
@@ -577,6 +587,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<long> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -615,6 +626,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<long> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -652,6 +664,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Long}" /> values.
         /// </summary>
@@ -731,6 +744,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<long?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
         {
@@ -817,6 +831,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<long?> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -894,6 +909,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<long?> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -970,6 +986,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="float" /> values.
         /// </summary>
@@ -1025,6 +1042,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<float> source, CancellationT
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<float> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
         {
@@ -1087,6 +1105,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<float> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1140,6 +1159,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<float> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1192,6 +1212,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Float}" /> values.
         /// </summary>
@@ -1267,6 +1288,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<float?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
         {
@@ -1349,6 +1371,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<float?> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1422,6 +1445,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<float?> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1494,6 +1518,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="double" /> values.
         /// </summary>
@@ -1549,6 +1574,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<double> source, Cancellatio
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<double> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
         {
@@ -1611,6 +1637,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<double> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1664,6 +1691,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<double> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1716,6 +1744,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Double}" /> values.
         /// </summary>
@@ -1791,6 +1820,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<double?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
         {
@@ -1873,6 +1903,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<double?> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1946,6 +1977,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<double?> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2018,6 +2050,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="decimal" /> values.
         /// </summary>
@@ -2058,6 +2091,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<decimal> source, Cancellat
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<decimal> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
         {
@@ -2105,6 +2139,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<decimal> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2143,6 +2178,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<decimal> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2180,6 +2216,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values.
         /// </summary>
@@ -2233,6 +2270,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<decimal?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
         {
@@ -2293,6 +2331,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<decimal?> MaxAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2344,6 +2383,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MaxAwaitWithCancellationAsync now exists as an overload of MaxByAsync.")]
         private static ValueTask<decimal?> MaxAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2394,6 +2434,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="int" /> values.
         /// </summary>
@@ -2434,6 +2475,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<int> source, CancellationToken
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<int> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default)
         {
@@ -2472,16 +2514,16 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="int"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="int"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<int> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2520,6 +2562,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<int> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2557,6 +2600,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Int}" /> values.
         /// </summary>
@@ -2612,6 +2656,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<int?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
         {
@@ -2665,16 +2710,16 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="Nullable{Int}"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Int}"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<int?> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2728,6 +2773,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<int?> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2780,6 +2826,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="long" /> values.
         /// </summary>
@@ -2820,6 +2867,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<long> source, CancellationTok
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<long> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
         {
@@ -2858,16 +2906,16 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="long"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="long"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<long> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2906,6 +2954,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<long> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2943,6 +2992,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Long}" /> values.
         /// </summary>
@@ -2998,6 +3048,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<long?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
         {
@@ -3051,16 +3102,16 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="Nullable{Long}"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Long}"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<long?> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3114,6 +3165,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<long?> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3166,6 +3218,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="float" /> values.
         /// </summary>
@@ -3222,6 +3275,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<float> source, CancellationT
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<float> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
         {
@@ -3276,16 +3330,16 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="float"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="float"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<float> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3340,6 +3394,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<float> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3393,6 +3448,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Float}" /> values.
         /// </summary>
@@ -3464,6 +3520,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<float?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
         {
@@ -3533,16 +3590,16 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="Nullable{Float}"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Float}"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<float?> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3612,6 +3669,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<float?> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3680,6 +3738,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="double" /> values.
         /// </summary>
@@ -3736,6 +3795,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<double> source, Cancellatio
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<double> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
         {
@@ -3790,16 +3850,16 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="double"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="double"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<double> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3854,6 +3914,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<double> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3907,6 +3968,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Double}" /> values.
         /// </summary>
@@ -3978,6 +4040,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<double?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
         {
@@ -4047,16 +4110,16 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="Nullable{Double}"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Double}"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<double?> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4126,6 +4189,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<double?> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4194,6 +4258,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="decimal" /> values.
         /// </summary>
@@ -4234,6 +4299,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<decimal> source, Cancellat
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<decimal> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
         {
@@ -4272,16 +4338,16 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="decimal"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="decimal"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<decimal> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4319,7 +4385,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-[GenerateAsyncOverload]
+        [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<decimal> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4357,6 +4424,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values.
         /// </summary>
@@ -4410,6 +4478,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return value;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         public static ValueTask<decimal?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
         {
@@ -4461,16 +4530,16 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         /// <summary>
-        /// Invokes and awaits a transform function on each element of a sequence and returns the minimum <see cref="Nullable{Decimal}"/> value.
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Decimal}"/> value.
         /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence to determine the minimum element of.</param>
-        /// <param name="selector">An asynchronous transform function to invoke and await on each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask sequence containing a single element with the value that corresponds to the minimum element in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<decimal?> MinAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4522,6 +4591,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by MinAwaitWithCancellationAsync now exists as an overload of MinByAsync.")]
         private static ValueTask<decimal?> MinAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt
index 95deebfc0..3e029a16c 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt
@@ -33,6 +33,7 @@ foreach (var m in new[] { "Max", "Min" })
             typeStr = "Nullable{" + t.Substring(0, 1).ToUpper() + t.Substring(1, t.Length - 2) + "}";
         }
 #>
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the <#=extremum#> value in an async-enumerable sequence of <see cref="<#=typeStr#>" /> values.
         /// </summary>
@@ -288,6 +289,7 @@ foreach (var m in new[] { "Max", "Min" })
 #>
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
 <#
 foreach (var overload in new[] {
@@ -299,7 +301,7 @@ foreach (var overload in new[] {
     var isAsync = overload.invoke.StartsWith("await");
     var isDeepCancellation = overload.selector.Contains("CancellationToken");
     var suffix = isAsync ? "Await" : "";
-    var visibility = isAsync ? "internal" : "public";
+    var visibility = isAsync ? "private" : "public";
     var core = isAsync ? "Core" : "";
 
     if (isDeepCancellation)
@@ -307,6 +309,27 @@ foreach (var overload in new[] {
         suffix += "WithCancellation";
 #>
 #if !NO_DEEP_CANCELLATION
+        [GenerateAsyncOverload]
+<#
+    } else if (isAsync)
+    {
+#>
+        /// <summary>
+        /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="<#=typeStr#>"/> value.
+        /// </summary>
+        /// <typeparam name="TSource">Type of elements in the source sequence.</typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="selector">An asynchronous transform function to invoke and await on each element of the source.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be usef for cancelling the sequence at any time.</param>
+        /// <returns>A ValueTask containing the maximum value in the sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
+        [GenerateAsyncOverload]
+<#
+    }
+    if (isDeepCancellation || isAsync)
+    {
+#>
+        [Obsolete("Use <#=m#>ByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by <#=m#><#=suffix#>Async now exists as an overload of <#=m#>ByAsync.")]
 <#
     }
 #>

From 9d76a28abd735c3493b6d863e9604fa23e6ff5f6 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 13:57:31 +0100
Subject: [PATCH 05/10] Handle remaining operators

---
 .../Linq/Operators/AsAsyncEnumerable.cs       |   2 +-
 .../System/Linq/Operators/Disposables.cs      |  23 +
 .../Operators/ToAsyncEnumerable.Observable.cs | 222 ++++++
 .../Linq/Operators/ToAsyncEnumerable.Task.cs  |  48 ++
 .../System/Linq/Operators/ToObservable.cs     |  83 +++
 .../System.Interactive.Async/TaskExt.cs       |   7 +
 .../AsyncOverloadsGenerator.cs                |   2 +-
 .../System/Linq/Operators/MinMax.Generated.cs |  80 ++
 .../System/Linq/Operators/MinMax.Generated.tt |  14 +
 .../System/Linq/Operators/OfType.cs           |   6 +
 .../System/Linq/Operators/OrderBy.cs          |  52 ++
 .../System/Linq/Operators/Range.cs            |   4 +
 .../System/Linq/Operators/Repeat.cs           |   4 +
 .../System/Linq/Operators/Reverse.cs          |   4 +
 .../System/Linq/Operators/Select.cs           |   9 +-
 .../System/Linq/Operators/SelectMany.cs       |  24 +
 .../System/Linq/Operators/SequenceEqual.cs    |   5 +
 .../System/Linq/Operators/Single.cs           |   8 +
 .../System/Linq/Operators/SingleOrDefault.cs  |   8 +
 .../System/Linq/Operators/Skip.cs             |   4 +
 .../System/Linq/Operators/SkipLast.cs         |   4 +
 .../System/Linq/Operators/SkipWhile.cs        |  10 +
 .../System/Linq/Operators/Sum.Generated.cs    | 210 ++----
 .../System/Linq/Operators/Sum.Generated.tt    |   5 +
 .../System/Linq/Operators/Take.cs             |   5 +
 .../System/Linq/Operators/TakeLast.cs         |   5 +
 .../System/Linq/Operators/TakeWhile.cs        |  10 +
 .../System/Linq/Operators/ToArray.cs          |   4 +
 .../Operators/ToAsyncEnumerable.Observable.cs |   8 +
 .../Linq/Operators/ToAsyncEnumerable.Task.cs  |   7 +
 .../System/Linq/Operators/ToDictionary.cs     |  20 +
 .../System/Linq/Operators/ToEnumerable.cs     |   1 +
 .../System/Linq/Operators/ToHashSet.cs        |   5 +
 .../System/Linq/Operators/ToList.cs           |   4 +
 .../System/Linq/Operators/ToLookup.cs         |  18 +
 .../System/Linq/Operators/ToObservable.cs     |   8 +
 .../System/Linq/Operators/Union.cs            |   5 +
 .../System/Linq/Operators/Where.cs            |  11 +
 .../System/Linq/Operators/Zip.cs              |  19 +
 ...alTests.SystemInteractiveAsync.received.cs | 145 ++++
 ...ystemInteractiveAsyncProviders.received.cs |  82 ++
 ...iApprovalTests.SystemLinqAsync.received.cs | 703 ++++++++++++++++++
 ...Tests.SystemLinqAsyncQueryable.received.cs | 413 ++++++++++
 43 files changed, 2167 insertions(+), 144 deletions(-)
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Disposables.cs
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs
 create mode 100644 Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToObservable.cs
 create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs
 create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs
 create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs
 create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs

diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs
index b40187c52..8a5eb3af7 100644
--- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/AsAsyncEnumerable.cs
@@ -10,7 +10,7 @@ public static partial class AsyncEnumerableEx
     {
         // NB: Synchronous LINQ to Objects doesn't hide the implementation of the source either.
 
-        // Note: this was previous in System.Linq.Async, but since .NET 10.0's System.Linq.AsyncEnumerable chose not to
+        // Note: this was previously in System.Linq.Async, but since .NET 10.0's System.Linq.AsyncEnumerable chose not to
         // implement it (even though Enumerable.AsEnumerable exists), we moved it into System.Interactive.Async so that
         // it remains available even after developers remove their dependency on the deprecated System.Linq.Async.
 
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Disposables.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Disposables.cs
new file mode 100644
index 000000000..e256e2017
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Disposables.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+using System.Threading;
+
+namespace System.Linq
+{
+    internal sealed class CancellationTokenDisposable : IDisposable
+    {
+        private readonly CancellationTokenSource _cts = new();
+
+        public CancellationToken Token => _cts.Token;
+
+        public void Dispose()
+        {
+            if (!_cts.IsCancellationRequested)
+            {
+                _cts.Cancel();
+            }
+        }
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs
new file mode 100644
index 000000000..5506aeffc
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs
@@ -0,0 +1,222 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerableEx
+    {
+        /// <summary>
+        /// Converts an observable sequence to an async-enumerable sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">Observable sequence to convert to an async-enumerable sequence.</param>
+        /// <returns>The async-enumerable sequence whose elements are pulled from the given observable sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+        public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this IObservable<TSource> source)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+
+            return new ObservableAsyncEnumerable<TSource>(source);
+        }
+
+        private sealed class ObservableAsyncEnumerable<TSource> : AsyncIterator<TSource>, IObserver<TSource>
+        {
+            private readonly IObservable<TSource> _source;
+
+            private ConcurrentQueue<TSource>? _values = new();
+            private Exception? _error;
+            private bool _completed;
+            private TaskCompletionSource<bool>? _signal;
+            private IDisposable? _subscription;
+            private CancellationTokenRegistration _ctr;
+
+            public ObservableAsyncEnumerable(IObservable<TSource> source) => _source = source;
+
+            public override AsyncIteratorBase<TSource> Clone() => new ObservableAsyncEnumerable<TSource>(_source);
+
+            public override ValueTask DisposeAsync()
+            {
+                Dispose();
+
+                return base.DisposeAsync();
+            }
+
+            protected override async ValueTask<bool> MoveNextCore()
+            {
+                //
+                // REVIEW: How often should we check? At the very least, we want to prevent
+                //         subscribing if cancellation is requested. A case may be made to
+                //         check for each iteration, namely because this operator is a bridge
+                //         with another interface. However, we also wire up cancellation to
+                //         the observable subscription, so there's redundancy here.
+                //
+                _cancellationToken.ThrowIfCancellationRequested();
+
+                switch (_state)
+                {
+                    case AsyncIteratorState.Allocated:
+                        //
+                        // NB: Breaking change to align with lazy nature of async iterators.
+                        //
+                        //     In previous implementations, the Subscribe call happened during
+                        //     the call to GetAsyncEnumerator.
+                        //
+                        // REVIEW: Confirm this design point. This implementation is compatible
+                        //         with an async iterator using "yield return", e.g. subscribing
+                        //         to the observable sequence and yielding values out of a local
+                        //         queue filled by observer callbacks. However, it departs from
+                        //         the dual treatment of Subscribe/GetEnumerator.
+                        //
+
+                        _subscription = _source.Subscribe(this);
+                        _ctr = _cancellationToken.Register(OnCanceled, state: null);
+                        _state = AsyncIteratorState.Iterating;
+                        goto case AsyncIteratorState.Iterating;
+
+                    case AsyncIteratorState.Iterating:
+                        while (true)
+                        {
+                            var completed = Volatile.Read(ref _completed);
+
+                            if (_values!.TryDequeue(out _current!))
+                            {
+                                return true;
+                            }
+                            else if (completed)
+                            {
+                                var error = _error;
+
+                                if (error != null)
+                                {
+                                    throw error;
+                                }
+
+                                return false;
+                            }
+
+                            await Resume().ConfigureAwait(false);
+                            Volatile.Write(ref _signal, null);
+                        }
+                }
+
+                await DisposeAsync().ConfigureAwait(false);
+                return false;
+            }
+
+            public void OnCompleted()
+            {
+                Volatile.Write(ref _completed, true);
+
+                DisposeSubscription();
+                OnNotification();
+            }
+
+            public void OnError(Exception error)
+            {
+                _error = error;
+                Volatile.Write(ref _completed, true);
+
+                DisposeSubscription();
+                OnNotification();
+            }
+
+            public void OnNext(TSource value)
+            {
+                _values?.Enqueue(value);
+
+                OnNotification();
+            }
+
+            private void OnNotification()
+            {
+                while (true)
+                {
+                    var signal = Volatile.Read(ref _signal);
+
+                    if (signal == TaskExt.True)
+                    {
+                        return;
+                    }
+
+                    if (signal != null)
+                    {
+                        signal.TrySetResult(true);
+                        return;
+                    }
+
+                    if (Interlocked.CompareExchange(ref _signal, TaskExt.True, null) == null)
+                    {
+                        return;
+                    }
+                }
+            }
+
+            private void Dispose()
+            {
+                _ctr.Dispose();
+                DisposeSubscription();
+
+                _values = null;
+                _error = null;
+            }
+
+            private void DisposeSubscription() => Interlocked.Exchange(ref _subscription, null)?.Dispose();
+
+            private void OnCanceled(object? state)
+            {
+                var cancelledTcs = default(TaskCompletionSource<bool>);
+
+                Dispose();
+
+                while (true)
+                {
+                    var signal = Volatile.Read(ref _signal);
+
+                    if (signal != null)
+                    {
+                        if (signal.TrySetCanceled(_cancellationToken))
+                            return;
+                    }
+
+                    if (cancelledTcs == null)
+                    {
+                        cancelledTcs = new TaskCompletionSource<bool>();
+                        cancelledTcs.TrySetCanceled(_cancellationToken);
+                    }
+
+                    if (Interlocked.CompareExchange(ref _signal, cancelledTcs, signal) == signal)
+                        return;
+                }
+            }
+
+            private Task Resume()
+            {
+                TaskCompletionSource<bool>? newSignal = null;
+
+                while (true)
+                {
+                    var signal = Volatile.Read(ref _signal);
+
+                    if (signal != null)
+                    {
+                        return signal.Task;
+                    }
+
+                    newSignal ??= new TaskCompletionSource<bool>();
+
+                    if (Interlocked.CompareExchange(ref _signal, newSignal, null) == null)
+                    {
+                        return newSignal.Task;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs
new file mode 100644
index 000000000..af1914347
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerableEx
+    {
+        /// <summary>
+        /// Converts a task to an async-enumerable sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source task.</typeparam>
+        /// <param name="task">Task to convert to an async-enumerable sequence.</param>
+        /// <returns>The async-enumerable sequence whose element is pulled from the given task.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="task"/> is null.</exception>
+        public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this Task<TSource> task)
+        {
+            if (task == null)
+                throw Error.ArgumentNull(nameof(task));
+
+            return new TaskToAsyncEnumerable<TSource>(task);
+        }
+
+        private sealed class TaskToAsyncEnumerable<T> : AsyncIterator<T>
+        {
+            private readonly Task<T> _task;
+
+            public TaskToAsyncEnumerable(Task<T> task) => _task = task;
+
+            public override AsyncIteratorBase<T> Clone() => new TaskToAsyncEnumerable<T>(_task);
+
+            protected override async ValueTask<bool> MoveNextCore()
+            {
+                if (_state == AsyncIteratorState.Allocated)
+                {
+                    _state = AsyncIteratorState.Iterating;
+                    _current = await _task.ConfigureAwait(false);
+                    return true;
+                }
+
+                return false;
+            }
+        }
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToObservable.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToObservable.cs
new file mode 100644
index 000000000..5be39166b
--- /dev/null
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/ToObservable.cs
@@ -0,0 +1,83 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+using System.Collections.Generic;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerableEx
+    {
+        /// <summary>
+        /// Converts an async-enumerable sequence to an observable sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">Enumerable sequence to convert to an observable sequence.</param>
+        /// <returns>The observable sequence whose elements are pulled from the given enumerable sequence.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+        public static IObservable<TSource> ToObservable<TSource>(this IAsyncEnumerable<TSource> source)
+        {
+            if (source == null)
+                throw Error.ArgumentNull(nameof(source));
+
+            return new ToObservableObservable<TSource>(source);
+        }
+
+        private sealed class ToObservableObservable<T> : IObservable<T>
+        {
+            private readonly IAsyncEnumerable<T> _source;
+
+            public ToObservableObservable(IAsyncEnumerable<T> source)
+            {
+                _source = source;
+            }
+
+            public IDisposable Subscribe(IObserver<T> observer)
+            {
+                var ctd = new CancellationTokenDisposable();
+
+                async void Core()
+                {
+                    await using var e = _source.GetAsyncEnumerator(ctd.Token);
+                    do
+                    {
+                        bool hasNext;
+                        var value = default(T)!;
+
+                        try
+                        {
+                            hasNext = await e.MoveNextAsync().ConfigureAwait(false);
+                            if (hasNext)
+                            {
+                                value = e.Current;
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            if (!ctd.Token.IsCancellationRequested)
+                            {
+                                observer.OnError(ex);
+                            }
+
+                            return;
+                        }
+
+                        if (!hasNext)
+                        {
+                            observer.OnCompleted();
+                            return;
+                        }
+
+                        observer.OnNext(value);
+                    }
+                    while (!ctd.Token.IsCancellationRequested);
+                }
+
+                // Fire and forget
+                Core();
+
+                return ctd;
+            }
+        }
+    }
+}
diff --git a/Ix.NET/Source/System.Interactive.Async/TaskExt.cs b/Ix.NET/Source/System.Interactive.Async/TaskExt.cs
index 18a0dee75..200cd6d9d 100644
--- a/Ix.NET/Source/System.Interactive.Async/TaskExt.cs
+++ b/Ix.NET/Source/System.Interactive.Async/TaskExt.cs
@@ -11,6 +11,13 @@ namespace System.Threading.Tasks
     internal static class TaskExt
     {
         public static readonly Task<bool> Never = new TaskCompletionSource<bool>().Task;
+        public static readonly TaskCompletionSource<bool> True;
+
+        static TaskExt()
+        {
+            True = new TaskCompletionSource<bool>();
+            True.SetResult(true);
+        }
 
 #if USE_FAIR_AND_CHEAPER_MERGE
         public static WhenAnyValueTask<T> WhenAny<T>(ValueTask<T>[] tasks)
diff --git a/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs b/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
index 6300d4b99..656072265 100644
--- a/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
+++ b/Ix.NET/Source/System.Linq.Async.SourceGenerator/AsyncOverloadsGenerator.cs
@@ -63,7 +63,7 @@ private static string GenerateOverloads(AsyncMethodGrouping grouping, Generation
             // to offer these even though we're decprecating System.Linq.Async, so they migrate into
             // System.Interactive.Async.) In those cases, the containing type is typically AsyncEnumerableEx,
             // but in System.Linq.Async it is AsyncEnumerable. So we need to discover the containing type name.
-            var containingTypeName = grouping.Methods.First().Symbol.ContainingType.Name;
+            var containingTypeName = grouping.Methods.FirstOrDefault()?.Symbol.ContainingType.Name ?? "AsyncEnumerable";
 
             var overloads = new StringBuilder();
             overloads.AppendLine("#nullable enable");
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs
index 68f9e205b..1ddb0773a 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs
@@ -53,6 +53,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<int> source, CancellationToken
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<int> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -89,6 +90,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="int"/> value.
         /// </summary>
@@ -176,6 +179,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Int}" /> values.
@@ -258,6 +262,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<int?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -333,6 +338,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Int}"/> value.
         /// </summary>
@@ -498,6 +505,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="long" /> values.
@@ -541,6 +549,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<long> source, CancellationTok
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<long> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -577,6 +586,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="long"/> value.
         /// </summary>
@@ -664,6 +675,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Long}" /> values.
@@ -746,6 +758,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<long?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -821,6 +834,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Long}"/> value.
         /// </summary>
@@ -986,6 +1001,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="float" /> values.
@@ -1044,6 +1060,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<float> source, CancellationT
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<float> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1095,6 +1112,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="float"/> value.
         /// </summary>
@@ -1212,6 +1231,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Float}" /> values.
@@ -1290,6 +1310,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<float?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1361,6 +1382,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Float}"/> value.
         /// </summary>
@@ -1518,6 +1541,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="double" /> values.
@@ -1576,6 +1600,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<double> source, Cancellatio
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<double> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1627,6 +1652,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="double"/> value.
         /// </summary>
@@ -1744,6 +1771,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Double}" /> values.
@@ -1822,6 +1850,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<double?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1893,6 +1922,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Double}"/> value.
         /// </summary>
@@ -2050,6 +2081,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="decimal" /> values.
@@ -2093,6 +2125,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<decimal> source, Cancellat
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<decimal> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2129,6 +2162,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="decimal"/> value.
         /// </summary>
@@ -2216,6 +2251,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the maximum value in an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values.
@@ -2272,6 +2308,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<decimal?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2321,6 +2358,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Decimal}"/> value.
         /// </summary>
@@ -2434,6 +2473,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="int" /> values.
@@ -2477,6 +2517,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<int> source, CancellationToken
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<int> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2513,6 +2554,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="int"/> value.
         /// </summary>
@@ -2600,6 +2643,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Int}" /> values.
@@ -2658,6 +2702,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<int?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2709,6 +2754,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Int}"/> value.
         /// </summary>
@@ -2826,6 +2873,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="long" /> values.
@@ -2869,6 +2917,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<long> source, CancellationTok
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<long> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -2905,6 +2954,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="long"/> value.
         /// </summary>
@@ -2992,6 +3043,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Long}" /> values.
@@ -3050,6 +3102,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<long?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3101,6 +3154,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Long}"/> value.
         /// </summary>
@@ -3218,6 +3273,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="float" /> values.
@@ -3277,6 +3333,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<float> source, CancellationT
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<float> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3329,6 +3386,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="float"/> value.
         /// </summary>
@@ -3448,6 +3507,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Float}" /> values.
@@ -3522,6 +3582,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<float?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3589,6 +3650,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Float}"/> value.
         /// </summary>
@@ -3738,6 +3801,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="double" /> values.
@@ -3797,6 +3861,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<double> source, Cancellatio
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<double> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -3849,6 +3914,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="double"/> value.
         /// </summary>
@@ -3968,6 +4035,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Double}" /> values.
@@ -4042,6 +4110,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<double?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4109,6 +4178,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Double}"/> value.
         /// </summary>
@@ -4258,6 +4329,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="decimal" /> values.
@@ -4301,6 +4373,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<decimal> source, Cancellat
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<decimal> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4337,6 +4410,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="decimal"/> value.
         /// </summary>
@@ -4424,6 +4499,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Returns the minimum value in an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values.
@@ -4480,6 +4556,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         public static ValueTask<decimal?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -4529,6 +4606,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
+#endif
+
         /// <summary>
         /// Invokes and awaits a transform function on each element of a sequence and returns the maximum <see cref="Nullable{Decimal}"/> value.
         /// </summary>
@@ -4642,5 +4721,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #endif
+
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt
index 3e029a16c..5eadc306a 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt
@@ -330,8 +330,13 @@ foreach (var overload in new[] {
     {
 #>
         [Obsolete("Use <#=m#>ByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the functionality previously provided by <#=m#><#=suffix#>Async now exists as an overload of <#=m#>ByAsync.")]
+<#
+    } else {
+#>
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 <#
     }
+
 #>
         <#=visibility#> static ValueTask<<#=t#>> <#=m#><#=suffix#>Async<#=core#><TSource>(this IAsyncEnumerable<TSource> source, <#=overload.selector#> selector, CancellationToken cancellationToken = default)
         {
@@ -589,6 +594,15 @@ foreach (var overload in new[] {
     {
 #>
 #endif
+
+<#
+    }
+
+    if (!(isDeepCancellation || isAsync))
+    {
+#>
+#endif
+
 <#
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OfType.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OfType.cs
index b9e2bb476..bbd94d939 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OfType.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OfType.cs
@@ -17,6 +17,11 @@ public static partial class AsyncEnumerable
         //         the source is not an option, because it would require users to specify two type arguments, unlike
         //         what's done in Enumerable.OfType. Should we move this method to Ix, thus doing away with OfType
         //         in the API surface altogether?
+        // IDG 2025/09/30: System.Linq.AsyncEnumerable implemented this one despite the limitations (and despite
+        //         not implementing AsAsyncEnumerable).
+
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.oftype?view=net-9.0-pp
 
         /// <summary>
         /// Filters the elements of an async-enumerable sequence based on the specified type.
@@ -43,5 +48,6 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<object?> source, [S
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs
index 5d16689bd..5d431b5a2 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs
@@ -11,6 +11,10 @@ namespace System.Linq
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.orderby?view=net-9.0-pp#system-linq-asyncenumerable-orderby-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+        // The method linked to above includes a comparer parameter with a default value of null.
+
         /// <summary>
         /// Sorts the elements of a sequence in ascending order according to a key.
         /// </summary>
@@ -22,6 +26,7 @@ public static partial class AsyncEnumerable
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer: null, descending: false, parent: null);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Sorts the elements of a sequence in ascending order according to a key obtained by invoking a transform function on each element and awaiting the result.
@@ -33,15 +38,20 @@ public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyn
         /// <returns>An ordered async-enumerable sequence whose elements are sorted according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByAwait functionality now exists as overloads of OrderBy.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null, descending: false, parent: null);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByAwaitWithCancellation functionality now exists as overloads of OrderBy.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null, descending: false, parent: null);
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.orderby?view=net-9.0-pp#system-linq-asyncenumerable-orderby-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+
         /// <summary>
         /// Sorts the elements of a sequence in ascending order by using a specified comparer.
         /// </summary>
@@ -54,6 +64,7 @@ private static IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellationCore
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer, descending: false, parent: null);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Sorts the elements of a sequence in ascending order by using a specified comparer. The keys are obtained by invoking the transform function on each element and awaiting the result.
@@ -66,15 +77,21 @@ public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyn
         /// <returns>An ordered async-enumerable sequence whose elements are sorted according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByAwait functionality now exists as overloads of OrderBy.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer, descending: false, parent: null);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByAwaitWithCancellation functionality now exists as overloads of OrderBy.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer, descending: false, parent: null);
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.orderbydescending?view=net-9.0-pp#system-linq-asyncenumerable-orderbydescending-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+        // The method linked to above includes a comparer parameter with a default value of null.
+
         /// <summary>
         /// Sorts the elements of a sequence in descending order according to a key.
         /// </summary>
@@ -86,6 +103,7 @@ private static IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellationCore
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer: null, descending: true, parent: null);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Sorts the elements of a sequence in descending order according to a key obtained by invoking a transform function on each element and awaiting the result.
@@ -97,15 +115,20 @@ public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(
         /// <returns>An ordered async-enumerable sequence whose elements are sorted in descending order according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByDescendingAwait functionality now exists as overloads of OrderByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null, descending: true, parent: null);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByDescendingAwaitWithCancellation functionality now exists as overloads of OrderByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null, descending: true, parent: null);
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.orderbydescending?view=net-9.0-pp#system-linq-asyncenumerable-orderbydescending-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+
         /// <summary>
         /// Sorts the elements of a sequence in descending order by using a specified comparer.
         /// </summary>
@@ -118,6 +141,7 @@ private static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancel
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer, descending: true, parent: null);
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Sorts the elements of a sequence in descending order by using a specified comparer. The keys are obtained by invoking the transform function on each element and awaiting the result.
@@ -130,15 +154,21 @@ public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(
         /// <returns>An ordered async-enumerable sequence whose elements are sorted in descending order according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByDescendingAwait functionality now exists as overloads of OrderByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer, descending: true, parent: null);
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the OrderByDescendingAwaitWithCancellation functionality now exists as overloads of OrderByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellationCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer, descending: true, parent: null);
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.thenby?view=net-9.0-pp#system-linq-asyncenumerable-thenby-2(system-linq-iorderedasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+        // The method linked to above includes a comparer parameter with a default value of null.
+
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
         /// </summary>
@@ -155,6 +185,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrder
 
             return source.CreateOrderedEnumerable(keySelector, comparer: null, descending: false);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in ascending order according to a key obtained by invoking a transform function on each element and awaiting the result.
@@ -166,6 +197,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrder
         /// <returns>An ordered async-enumerable whose elements are sorted according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByAwait functionality now exists as overloads of ThenBy.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByAwaitCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
         {
             if (source == null)
@@ -176,6 +208,7 @@ private static IOrderedAsyncEnumerable<TSource> ThenByAwaitCore<TSource, TKey>(t
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByAwaitWithCancellation functionality now exists as overloads of ThenBy.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellationCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector)
         {
             if (source == null)
@@ -185,6 +218,9 @@ private static IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellationCore<
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.thenby?view=net-9.0-pp#system-linq-asyncenumerable-thenby-2(system-linq-iorderedasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in ascending order by using a specified comparer.
         /// </summary>
@@ -202,6 +238,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrder
 
             return source.CreateOrderedEnumerable(keySelector, comparer, descending: false);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in ascending order by using a specified comparer. The keys are obtained by invoking a transform function on each element and awaiting the result.
@@ -214,6 +251,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrder
         /// <returns>An ordered async-enumerable whose elements are sorted according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByAwait functionality now exists as overloads of ThenBy.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByAwaitCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
@@ -224,6 +262,7 @@ private static IOrderedAsyncEnumerable<TSource> ThenByAwaitCore<TSource, TKey>(t
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByAwaitWithCancellation functionality now exists as overloads of ThenBy.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellationCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
@@ -233,6 +272,10 @@ private static IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellationCore<
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.thenbydescending?view=net-9.0-pp#system-linq-asyncenumerable-thenbydescending-2(system-linq-iorderedasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+        // The method linked to above includes a comparer parameter with a default value of null.
+
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in descending order, according to a key.
         /// </summary>
@@ -249,6 +292,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(t
 
             return source.CreateOrderedEnumerable(keySelector, comparer: null, descending: true);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in descending order, according to a key obtained by invoking a transform function on each element and awaiting the result.
@@ -260,6 +304,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(t
         /// <returns>An ordered async-enumerable sequence whose elements are sorted in descending order according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByDescendingAwait functionality now exists as overloads of ThenByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
         {
             if (source == null)
@@ -270,6 +315,7 @@ private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitCore<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByDescendingAwaitWithCancellation functionality now exists as overloads of ThenByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellationCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector)
         {
             if (source == null)
@@ -279,6 +325,9 @@ private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancell
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.thenbydescending?view=net-9.0-pp#system-linq-asyncenumerable-thenbydescending-2(system-linq-iorderedasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-icomparer((-1)))
+
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in descending order by using a specified comparer.
         /// </summary>
@@ -296,6 +345,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(t
 
             return source.CreateOrderedEnumerable(keySelector, comparer, descending: true);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in descending order by using a specified comparer. The keys are obtained by invoking a transform function on each element and awaiting the result.
@@ -308,6 +358,7 @@ public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(t
         /// <returns>An ordered async-enumerable sequence whose elements are sorted in descending order according to a key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByDescendingAwait functionality now exists as overloads of ThenByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
@@ -318,6 +369,7 @@ private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitCore<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ThenByDescendingAwaitWithCancellation functionality now exists as overloads of ThenByDescending.")]
         private static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellationCore<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs
index 013a1b00a..77bf5a21b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs
@@ -11,6 +11,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.range?view=net-9.0-pp
+
         /// <summary>
         /// Generates an async-enumerable sequence of integral numbers within a specified range.
         /// </summary>
@@ -144,5 +147,6 @@ async ValueTask<bool> Core()
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs
index b89feb64c..45f12bace 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.repeat?view=net-9.0-pp
+
         /// <summary>
         /// Generates an async-enumerable sequence that repeats the given element the specified number of times.
         /// </summary>
@@ -99,5 +102,6 @@ protected override async ValueTask<bool> MoveNextCore()
                 return false;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs
index 13f314d23..54732b0d1 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs
@@ -11,6 +11,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.reverse?view=net-9.0-pp
+
         /// <summary>
         /// Inverts the order of the elements in a sequence.
         /// </summary>
@@ -115,5 +118,6 @@ protected override async ValueTask<bool> MoveNextCore()
                 return false;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs
index ff8383c30..493882c47 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs
@@ -36,7 +36,8 @@ public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnum
                 _ => new SelectEnumerableAsyncIterator<TSource, TResult>(source, selector),
             };
         }
-#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.select?view=net-9.0-pp#system-linq-asyncenumerable-select-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-int32-1)))
 
         /// <summary>
         /// Projects each element of an async-enumerable sequence into a new form by incorporating the element's index.
@@ -71,6 +72,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Projects each element of an async-enumerable sequence into a new form by applying an asynchronous selector function to each member of the source sequence and awaiting the result.
@@ -82,7 +84,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence whose elements are the result of invoking the transform function on each element of the source sequence and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         [GenerateAsyncOverload]
-        [Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the AggregateAwait and AggregateAwaitWithCancellationAsync functionality now exists as overloads of Aggregate.")]
+        [Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectAwait functionality now exists as overloads of Select.")]
         private static IAsyncEnumerable<TResult> SelectAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
         {
             if (source == null)
@@ -100,6 +102,7 @@ private static IAsyncEnumerable<TResult> SelectAwaitCore<TSource, TResult>(this
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectAwaitWithCancellation functionality now exists as overloads of Select.")]
         private static IAsyncEnumerable<TResult> SelectAwaitWithCancellationCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
         {
             if (source == null)
@@ -126,6 +129,7 @@ private static IAsyncEnumerable<TResult> SelectAwaitWithCancellationCore<TSource
         /// <returns>An async-enumerable sequence whose elements are the result of invoking the transform function on each element and its index of the source sequence and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectAwait functionality now exists as overloads of Select.")]
         private static IAsyncEnumerable<TResult> SelectAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<TResult>> selector)
         {
             if (source == null)
@@ -153,6 +157,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectAwaitWithCancellation functionality now exists as overloads of Select.")]
         private static IAsyncEnumerable<TResult> SelectAwaitWithCancellationCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<TResult>> selector)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SelectMany.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SelectMany.cs
index e70b194cf..0b0d190c8 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SelectMany.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SelectMany.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.selectmany?view=net-9.0-pp#system-linq-asyncenumerable-selectmany-3(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-collections-generic-iasyncenumerable((-1))))-system-func((-0-1-2)))
+
         /// <summary>
         /// Projects each element of an async-enumerable sequence to an async-enumerable sequence and merges the resulting async-enumerable sequences into one async-enumerable sequence.
         /// </summary>
@@ -28,6 +31,7 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsync
 
             return new SelectManyAsyncIterator<TSource, TResult>(source, selector);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         // REVIEW: Should we keep these overloads that return ValueTask<IAsyncEnumerable<TResult>>? One could argue the selector is async twice.
 
@@ -41,6 +45,7 @@ public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsync
         /// <returns>An async-enumerable sequence whose elements are the result of invoking the one-to-many transform function on each element of the source sequence and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
@@ -53,6 +58,7 @@ private static IAsyncEnumerable<TResult> SelectManyAwaitCore<TSource, TResult>(t
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwaitWithCancellation functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellationCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
@@ -64,6 +70,9 @@ private static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellationCore<TSo
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.selectmany?view=net-9.0-pp#system-linq-asyncenumerable-selectmany-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-int32-system-collections-generic-iasyncenumerable((-1)))))
+
         /// <summary>
         /// Projects each element of an async-enumerable sequence to an async-enumerable sequence by incorporating the element's index and merges the resulting async-enumerable sequences into one async-enumerable sequence.
         /// </summary>
@@ -102,6 +111,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Projects each element of an async-enumerable sequence into an async-enumerable sequence by incorporating the element's index and merges the resulting async-enumerable sequences into an async-enumerable sequence.
@@ -113,6 +123,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence who's elements are the result of invoking the one-to-many transform function on each element of the source sequence and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
@@ -145,6 +156,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwaitWithCancellation functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellationCore<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
@@ -176,6 +188,9 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.selectmany?view=net-9.0-pp#system-linq-asyncenumerable-selectmany-3(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-collections-generic-iasyncenumerable((-1))))-system-func((-0-1-2)))
+
         /// <summary>
         /// Projects each element of an async-enumerable sequence to an async-enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one async-enumerable sequence.
         /// </summary>
@@ -211,6 +226,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Projects each element of an async-enumerable sequence to an async-enumerable sequence by awaiting the result of a transform function, invokes the result selector for each of the source elements and each of the corrasponding inner-sequence's elements and awaits the result, and merges the results into one async-enumerable sequence.
@@ -224,6 +240,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence whose elements are the result of invoking the one-to-many transform function <paramref name="collectionSelector"/> on each element of the input sequence, awaiting the result, applying <paramref name="resultSelector"/> to each element of the intermediate sequences along with their corrasponding source element and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="collectionSelector"/>, or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitCore<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
@@ -251,6 +268,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwaitWithCancellation functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellationCore<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
@@ -277,6 +295,9 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.selectmany?view=net-9.0-pp#system-linq-asyncenumerable-selectmany-3(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-int32-system-collections-generic-ienumerable((-1))))-system-func((-0-1-2)))
+
         /// <summary>
         /// Projects each element of an async-enumerable sequence to an async-enumerable sequence by incorporating the element's index, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one async-enumerable sequence.
         /// </summary>
@@ -319,6 +340,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Projects each element of an async-enumerable sequence to an async-enumerable sequence by awaiting the result of a transform function that incorporates each element's index,
@@ -333,6 +355,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence whose elements are the result of invoking the one-to-many transform function <paramref name="collectionSelector"/> on each element of the input sequence, awaiting the result, applying <paramref name="resultSelector"/> to each element of the intermediate sequences olong with their corrasponding source element and awaiting the result.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="collectionSelector"/>, or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitCore<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
@@ -367,6 +390,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SelectManyAwaitWithCancellation functionality now exists as overloads of SelectMany.")]
         private static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellationCore<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SequenceEqual.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SequenceEqual.cs
index 801cd734b..df2fb804b 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SequenceEqual.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SequenceEqual.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.sequenceequalasync?view=net-9.0-pp
+        // The method above covers the next two overloads because it supplies a default null value for comparer.
+
         /// <summary>
         /// Determines whether two sequences are equal by comparing the elements pairwise.
         /// </summary>
@@ -84,5 +88,6 @@ static async ValueTask<bool> Core(IAsyncEnumerable<TSource> first, IAsyncEnumera
                 return !await e2.MoveNextAsync();
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Single.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Single.cs
index 8f2aef284..aa0ae170e 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Single.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Single.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.singleasync?view=net-9.0-pp#system-linq-asyncenumerable-singleasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the only element of an async-enumerable sequence, and reports an exception if there is not exactly one element in the async-enumerable sequence.
         /// </summary>
@@ -56,6 +59,8 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Cancellat
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.singleasync?view=net-9.0-pp#system-linq-asyncenumerable-singleasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the only element of an async-enumerable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the async-enumerable sequence.
         /// </summary>
@@ -101,6 +106,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 throw Error.NoElements();
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Returns the only element of an async-enumerable sequence that satisfies the condition in the asynchronous predicate, and reports an exception if there is not exactly one element in the async-enumerable sequence that matches the predicate.
@@ -113,6 +119,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SingleAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SingleAwaitAsync functionality now exists as overloads of SingleAsync.")]
         private static ValueTask<TSource> SingleAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -151,6 +158,7 @@ static async ValueTask<TSource> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SingleAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SingleAwaitWithCancellationAsync functionality now exists as overloads of SingleAsync.")]
         private static ValueTask<TSource> SingleAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleOrDefault.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleOrDefault.cs
index 08e0c7e9e..c7aa9edcd 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleOrDefault.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleOrDefault.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.singleordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-singleordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the only element of an async-enumerable sequence, or a default value if the async-enumerable sequence is empty; this method reports an exception if there is more than one element in the async-enumerable sequence.
         /// </summary>
@@ -57,6 +60,8 @@ public static partial class AsyncEnumerable
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.singleordefaultasync?view=net-9.0-pp#system-linq-asyncenumerable-singleordefaultasync-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean))-system-threading-cancellationtoken)
+
         /// <summary>
         /// Returns the only element of an async-enumerable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the async-enumerable sequence.
         /// </summary>
@@ -102,6 +107,7 @@ public static partial class AsyncEnumerable
                 return default;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Returns the only element of an async-enumerable sequence that satisfies the condition in the asynchronous predicate, or a default value if no such element exists, and reports an exception if there is more than one element in the async-enumerable sequence that matches the predicate.
@@ -114,6 +120,7 @@ public static partial class AsyncEnumerable
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) More than one element satisfies the condition in the predicate.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SingleOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SingleOrDefaultAwaitAsync functionality now exists as overloads of SingleOrDefaultAsync.")]
         private static ValueTask<TSource?> SingleOrDefaultAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -152,6 +159,7 @@ public static partial class AsyncEnumerable
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SingleOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SingleOrDefaultAwaitWithCancellationAsync functionality now exists as overloads of SingleOrDefaultAsync.")]
         private static ValueTask<TSource?> SingleOrDefaultAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Skip.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Skip.cs
index 8fd12a350..fb463e414 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Skip.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Skip.cs
@@ -8,6 +8,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.skip?view=net-9.0-pp
+
         /// <summary>
         /// Bypasses a specified number of elements in an async-enumerable sequence and then returns the remaining elements.
         /// </summary>
@@ -44,5 +47,6 @@ public static IAsyncEnumerable<TSource> Skip<TSource>(this IAsyncEnumerable<TSou
 
             return new AsyncEnumerablePartition<TSource>(source, count, -1);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipLast.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipLast.cs
index fab55d968..b47f97ccd 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipLast.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipLast.cs
@@ -11,6 +11,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.skiplast?view=net-9.0-pp
+
         /// <summary>
         /// Bypasses a specified number of elements at the end of an async-enumerable sequence.
         /// </summary>
@@ -68,5 +71,6 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, in
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipWhile.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipWhile.cs
index a30e7bcfa..c5c03d38c 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipWhile.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipWhile.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.skipwhile?view=net-9.0-pp#system-linq-asyncenumerable-skipwhile-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean)))
+
         /// <summary>
         /// Bypasses elements in an async-enumerable sequence as long as a specified condition is true and then returns the remaining elements.
         /// </summary>
@@ -50,6 +53,8 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.skipwhile?view=net-9.0-pp#system-linq-asyncenumerable-skipwhile-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-int32-system-boolean)))
+
         /// <summary>
         /// Bypasses elements in an async-enumerable sequence as long as a specified condition is true and then returns the remaining elements.
         /// The element's index is used in the logic of the predicate function.
@@ -96,6 +101,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Bypasses elements in an async-enumerable sequence as long as a condition is true, and then returns the remaining elements.
@@ -106,6 +112,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence containing the elements in the source sequence starting at the first element that does not pass the test specified by the predicate.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SkipWhileAwait functionality now exists as overloads of SkipWhile.")]
         private static IAsyncEnumerable<TSource> SkipWhileAwaitCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -140,6 +147,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SkipWhileAwaitWithCancellation functionality now exists as overloads of SkipWhile.")]
         private static IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellationCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -183,6 +191,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence containing the elements in the source sequence starting at the first element that does not pass the test specified by the predicate.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SkipWhileAwait functionality now exists as overloads of SkipWhile.")]
         private static IAsyncEnumerable<TSource> SkipWhileAwaitCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -223,6 +232,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the SkipWhileAwaitWithCancellation functionality now exists as overloads of SkipWhile.")]
         private static IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellationCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs
index cd9be75fa..9829a4f90 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs
@@ -10,6 +10,7 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="int" /> values.
         /// </summary>
@@ -40,6 +41,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<int> source, CancellationToken
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="int" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -51,6 +53,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<int> source, CancellationToken
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<int> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -78,18 +81,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="int"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<int> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<int> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -117,8 +110,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<int> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<int> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -146,6 +139,7 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="long" /> values.
         /// </summary>
@@ -176,6 +170,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<long> source, CancellationTok
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -187,6 +182,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<long> source, CancellationTok
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<long> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -214,18 +210,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="long"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<long> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<long> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -253,8 +239,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<long> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<long> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -282,6 +268,7 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="float" /> values.
         /// </summary>
@@ -309,6 +296,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<float> source, CancellationT
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -320,6 +308,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<float> source, CancellationT
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<float> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -344,18 +333,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="float"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<float> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<float> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -380,8 +359,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<float> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<float> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -406,6 +385,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="double" /> values.
         /// </summary>
@@ -433,6 +413,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<double> source, Cancellatio
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -444,6 +425,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<double> source, Cancellatio
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<double> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -468,18 +450,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="double"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<double> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -504,8 +476,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<double> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -530,6 +502,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="decimal" /> values.
         /// </summary>
@@ -557,6 +530,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<decimal> source, Cancellat
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="decimal" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -568,6 +542,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<decimal> source, Cancellat
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<decimal> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -592,18 +567,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="decimal"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<decimal> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -628,8 +593,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<decimal> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -654,6 +619,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Int}" /> values.
         /// </summary>
@@ -684,6 +650,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Int}" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -695,6 +662,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<int?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -722,18 +690,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="Nullable{Int}"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<int?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<int?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -761,8 +719,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<int?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<int?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -790,6 +748,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Long}" /> values.
         /// </summary>
@@ -820,6 +779,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Long}" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -831,6 +791,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<long?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -858,18 +819,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="Nullable{Long}"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<long?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<long?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -897,8 +848,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<long?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<long?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -926,6 +877,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Float}" /> values.
         /// </summary>
@@ -953,6 +905,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Float}" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -964,6 +917,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<float?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -988,18 +942,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="Nullable{Float}"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<float?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<float?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1024,8 +968,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<float?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<float?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1050,6 +994,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Double}" /> values.
         /// </summary>
@@ -1077,6 +1022,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Double}" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -1088,6 +1034,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<double?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1112,18 +1059,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="Nullable{Double}"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<double?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1148,8 +1085,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<double?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1174,6 +1111,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Decimal}" /> values.
         /// </summary>
@@ -1201,6 +1139,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="Nullable{Decimal}" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -1212,6 +1151,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<decimal?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1236,18 +1176,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-        /// <summary>
-        /// Computes the sum of a sequence of <see cref="Nullable{Decimal}"/> values that are obtained by invoking a transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values that are used to calculate a sum.</param>
-        /// <param name="selector">An asynchronous transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the sum of the values in the source sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<decimal?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1272,8 +1202,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
 #if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
+        internal static ValueTask<decimal?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt
index d765430fe..c2866e384 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt
@@ -40,6 +40,7 @@ foreach (var o in os)
         typeStr = "Nullable{" + o.type.Substring(0, 1).ToUpper() + o.type.Substring(1, o.type.Length - 2) + "}";
     }
 #>
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
         /// Computes the sum of a sequence of <see cref="<#=typeStr#>" /> values.
         /// </summary>
@@ -83,6 +84,7 @@ else
                 return sum;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Computes the sum of a sequence of <see cref="<#=typeStr#>" /> values that are obtained by invoking a transform function on each element of the input sequence.
@@ -94,6 +96,7 @@ else
         /// <returns>An async-enumerable sequence containing a single element with the sum of the values in the source sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static ValueTask<<#=o.type#>> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, <#=o.type#>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -134,6 +137,7 @@ else
             }
         }
 
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         internal static ValueTask<<#=o.type#>> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -175,6 +179,7 @@ else
         }
 
 #if !NO_DEEP_CANCELLATION
+        [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         internal static ValueTask<<#=o.type#>> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Take.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Take.cs
index b5820dccf..b7d9b547f 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Take.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Take.cs
@@ -8,6 +8,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.take?view=net-9.0-pp#system-linq-asyncenumerable-take-1(system-collections-generic-iasyncenumerable((-0))-system-int32)
+
         /// <summary>
         /// Returns a specified number of contiguous elements from the start of an async-enumerable sequence.
         /// </summary>
@@ -37,5 +41,6 @@ public static IAsyncEnumerable<TSource> Take<TSource>(this IAsyncEnumerable<TSou
 
             return new AsyncEnumerablePartition<TSource>(source, 0, count - 1);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeLast.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeLast.cs
index 19f27bc4b..76c1a641e 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeLast.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeLast.cs
@@ -11,6 +11,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.takelast?view=net-9.0-pp
+
         /// <summary>
         /// Returns a specified number of contiguous elements from the end of an async-enumerable sequence.
         /// </summary>
@@ -77,5 +81,6 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, in
                 while (queue.Count > 0);
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeWhile.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeWhile.cs
index d214e48c2..2f34b0dbf 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeWhile.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeWhile.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.takewhile?view=net-9.0-pp#system-linq-asyncenumerable-takewhile-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean)))
+
         /// <summary>
         /// Returns elements from an async-enumerable sequence as long as a specified condition is true.
         /// </summary>
@@ -41,6 +44,8 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.takewhile?view=net-9.0-pp#system-linq-asyncenumerable-takewhile-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-int32-system-boolean)))
+
         /// <summary>
         /// Returns elements from an async-enumerable sequence as long as a specified condition is true.
         /// The element's index is used in the logic of the predicate function.
@@ -79,6 +84,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Returns elements from an async-enumerable sequence as long as a specified condition is true.
@@ -89,6 +95,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the TakeWhileAwait functionality now exists as overloads of TakeWhile.")]
         private static IAsyncEnumerable<TSource> TakeWhileAwaitCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -114,6 +121,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the TakeWhileAwaitWithCancellation functionality now exists as overloads of TakeWhile.")]
         private static IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellationCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -148,6 +156,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the TakeWhileAwait functionality now exists as overloads of TakeWhile.")]
         private static IAsyncEnumerable<TSource> TakeWhileAwaitCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -180,6 +189,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the TakeWhileAwaitWithCancellation functionality now exists as overloads of TakeWhile.")]
         private static IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellationCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToArray.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToArray.cs
index 7b731b8ea..34009ae90 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToArray.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToArray.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.toarrayasync?view=net-9.0-pp
+
         /// <summary>
         /// Creates an array from an async-enumerable sequence.
         /// </summary>
@@ -29,5 +32,6 @@ public static ValueTask<TSource[]> ToArrayAsync<TSource>(this IAsyncEnumerable<T
 
             return AsyncEnumerableHelpers.ToArray(source, cancellationToken);
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs
index 700401e81..f8f23a655 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs
@@ -11,6 +11,13 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // Moved to AsyncEnumerableEx in System.Interactive.Async.
+        // System.Linq.AsyncEnumerable has chosen not to implement this. We continue to implement this because
+        // we believe it is a useful feature, but since it's now in the category of LINQ-adjacent functionality
+        // not built into the .NET runtime libraries, it now lives in System.Interactive.Async.
+
         /// <summary>
         /// Converts an observable sequence to an async-enumerable sequence.
         /// </summary>
@@ -218,5 +225,6 @@ private Task Resume()
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs
index 400289b05..61e6f23e9 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Task.cs
@@ -9,6 +9,12 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // Moved to AsyncEnumerableEx in System.Interactive.Async.
+        // System.Linq.AsyncEnumerable has chosen not to implement this. We continue to implement this because
+        // we believe it is a useful feature, but since it's now in the category of LINQ-adjacent functionality
+        // not built into the .NET runtime libraries, it now lives in System.Interactive.Async.
+
         /// <summary>
         /// Converts a task to an async-enumerable sequence.
         /// </summary>
@@ -44,5 +50,6 @@ protected override async ValueTask<bool> MoveNextCore()
                 return false;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToDictionary.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToDictionary.cs
index 97cfedf87..0fa9fcb3e 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToDictionary.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToDictionary.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.todictionaryasync?view=net-9.0-pp#system-linq-asyncenumerable-todictionaryasync-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-iequalitycomparer((-1))-system-threading-cancellationtoken)
+        // That one overload covers the next two methods, because it supplieds a default comparer.
+
         /// <summary>
         /// Creates a dictionary from an async-enumerable sequence according to a specified key selector function.
         /// </summary>
@@ -59,6 +63,7 @@ static async ValueTask<Dictionary<TKey, TSource>> Core(IAsyncEnumerable<TSource>
                 return d;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Creates a dictionary from an async-enumerable sequence by invoking a key-selector function on each element and awaiting the result.
@@ -72,6 +77,7 @@ static async ValueTask<Dictionary<TKey, TSource>> Core(IAsyncEnumerable<TSource>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) where TKey : notnull =>
             ToDictionaryAwaitAsyncCore<TSource, TKey>(source, keySelector, comparer: null, cancellationToken);
 
@@ -88,6 +94,7 @@ private static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsyncCore<T
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="comparer"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default) where TKey : notnull
         {
             if (source == null)
@@ -114,10 +121,12 @@ static async ValueTask<Dictionary<TKey, TSource>> Core(IAsyncEnumerable<TSource>
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) where TKey : notnull =>
             ToDictionaryAwaitWithCancellationAsyncCore(source, keySelector, comparer: null, cancellationToken);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default) where TKey : notnull
         {
             if (source == null)
@@ -143,6 +152,12 @@ static async ValueTask<Dictionary<TKey, TSource>> Core(IAsyncEnumerable<TSource>
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.todictionaryasync?view=net-9.0-pp#system-linq-asyncenumerable-todictionaryasync-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-iequalitycomparer((-1))-system-threading-cancellationtoken)
+        // The method above provides the functionality for each of the next two methods, although because it does so with a
+        // single method that provides a default null value for the comparer, it it's not a strict source-compatible
+        // replacement. But there's not much we can do about that.
+
         /// <summary>
         /// Creates a dictionary from an async-enumerable sequence according to a specified key selector function, and an element selector function.
         /// </summary>
@@ -199,6 +214,7 @@ static async ValueTask<Dictionary<TKey, TElement>> Core(IAsyncEnumerable<TSource
                 return d;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Creates a dictionary from an async-enumerable sequence using the specified asynchronous key and element selector functions.
@@ -214,6 +230,7 @@ static async ValueTask<Dictionary<TKey, TElement>> Core(IAsyncEnumerable<TSource
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) where TKey : notnull =>
             ToDictionaryAwaitAsyncCore<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
@@ -232,6 +249,7 @@ private static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsyncCore<
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="comparer"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default) where TKey : notnull
         {
             if (source == null)
@@ -261,10 +279,12 @@ static async ValueTask<Dictionary<TKey, TElement>> Core(IAsyncEnumerable<TSource
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) where TKey : notnull =>
             ToDictionaryAwaitWithCancellationAsyncCore(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as overloads of ToDictionaryAsync.")]
         private static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default) where TKey : notnull
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToEnumerable.cs
index ab6f99e7f..bddecb8a7 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToEnumerable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToEnumerable.cs
@@ -19,6 +19,7 @@ public static partial class AsyncEnumerable
         /// <param name="source">An async-enumerable sequence to convert to an enumerable sequence.</param>
         /// <returns>The enumerable sequence containing the elements in the async-enumerable sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+        [Obsolete("IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and it does not implement this method because 'sync over async' of this kind is an anti-pattern. Please use a different strategy.")]
         public static IEnumerable<TSource> ToEnumerable<TSource>(this IAsyncEnumerable<TSource> source)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToHashSet.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToHashSet.cs
index 2bf7c487f..a2cb32a04 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToHashSet.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToHashSet.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.tohashsetasync?view=net-9.0-pp
+        // That one overload covers the next two methods, because it supplieds a default comparer.
+
         /// <summary>
         /// Creates a hash set from an async-enumerable sequence.
         /// </summary>
@@ -51,5 +55,6 @@ static async ValueTask<HashSet<TSource>> Core(IAsyncEnumerable<TSource> source,
                 return set;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToList.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToList.cs
index 6c50505d4..d5ed2294a 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToList.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToList.cs
@@ -10,6 +10,9 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.tolistasync?view=net-9.0-pp
+
         /// <summary>
         /// Creates a list from an async-enumerable sequence.
         /// </summary>
@@ -41,5 +44,6 @@ static async ValueTask<List<TSource>> Core(IAsyncEnumerable<TSource> source, Can
                 return list;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToLookup.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToLookup.cs
index 4ad7f7e04..a57f98dea 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToLookup.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToLookup.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.tolookupasync?view=net-9.0-pp#system-linq-asyncenumerable-tolookupasync-2(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-collections-generic-iequalitycomparer((-1))-system-threading-cancellationtoken)
+        // That one overload covers the next two methods, because it supplieds a default comparer.
+
         /// <summary>
         /// Creates a lookup from an async-enumerable sequence according to a specified key selector function.
         /// </summary>
@@ -50,6 +54,7 @@ static async ValueTask<ILookup<TKey, TSource>> Core(IAsyncEnumerable<TSource> so
                 return await Internal.Lookup<TKey, TSource>.CreateAsync(source, keySelector, comparer, cancellationToken).ConfigureAwait(false);
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Creates a lookup from an async-enumerable sequence by invoking a key-selector function on each element and awaiting the result.
@@ -63,6 +68,7 @@ static async ValueTask<ILookup<TKey, TSource>> Core(IAsyncEnumerable<TSource> so
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
             ToLookupAwaitAsyncCore<TSource, TKey>(source, keySelector, comparer:null, cancellationToken);
 
@@ -79,6 +85,7 @@ private static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitAsyncCore<TSource,
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="comparer"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -96,10 +103,12 @@ static async ValueTask<ILookup<TKey, TSource>> Core(IAsyncEnumerable<TSource> so
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitWithCancellationAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
             ToLookupAwaitWithCancellationAsyncCore(source, keySelector, comparer: null, cancellationToken);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitWithCancellationAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsyncCore<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -116,6 +125,10 @@ static async ValueTask<ILookup<TKey, TSource>> Core(IAsyncEnumerable<TSource> so
         }
 #endif
 
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.tolookupasync?view=net-9.0-pp#system-linq-asyncenumerable-tolookupasync-3(system-collections-generic-iasyncenumerable((-0))-system-func((-0-1))-system-func((-0-2))-system-collections-generic-iequalitycomparer((-1))-system-threading-cancellationtoken)
+        // That one overload covers the next two methods, because it supplieds a default comparer.
+
         /// <summary>
         /// Creates a lookup from an async-enumerable sequence according to a specified key selector function, and an element selector function.
         /// </summary>
@@ -162,6 +175,7 @@ static async ValueTask<ILookup<TKey, TElement>> Core(IAsyncEnumerable<TSource> s
                 return await Internal.Lookup<TKey, TElement>.CreateAsync(source, keySelector, elementSelector, comparer, cancellationToken).ConfigureAwait(false);
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Creates a lookup from an async-enumerable sequence by invoking key and element selector functions on each source element and awaiting the results.
@@ -177,6 +191,7 @@ static async ValueTask<ILookup<TKey, TElement>> Core(IAsyncEnumerable<TSource> s
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
             ToLookupAwaitAsyncCore<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
@@ -195,6 +210,7 @@ private static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitAsyncCore<TSource
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> or <paramref name="elementSelector"/> or <paramref name="comparer"/> is null.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -214,10 +230,12 @@ static async ValueTask<ILookup<TKey, TElement>> Core(IAsyncEnumerable<TSource> s
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitWithCancellationAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
             ToLookupAwaitWithCancellationAsyncCore(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
         [GenerateAsyncOverload]
+        [Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ToLookupAwaitWithCancellationAsync functionality now exists as overloads of ToLookupAsync.")]
         private static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsyncCore<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey>? comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs
index 0e60ff045..464233d3a 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs
@@ -8,6 +8,13 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // Moved to AsyncEnumerableEx in System.Interactive.Async.
+        // System.Linq.AsyncEnumerable has chosen not to implement this. We continue to implement this because
+        // we believe it is a useful feature, but since it's now in the category of LINQ-adjacent functionality
+        // not built into the .NET runtime libraries, it now lives in System.Interactive.Async.
+
         /// <summary>
         /// Converts an async-enumerable sequence to an observable sequence.
         /// </summary>
@@ -79,5 +86,6 @@ async void Core()
                 return ctd;
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs
index 1537a05d2..7ac699ecb 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs
@@ -11,6 +11,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.union?view=net-9.0-pp
+        // That one overload covers the next two methods, because it supplieds a default comparer.
+
         /// <summary>
         /// Produces the set union of two sequences by using the default equality comparer.
         /// </summary>
@@ -290,5 +294,6 @@ internal override UnionAsyncIterator<TSource> Union(IAsyncEnumerable<TSource> ne
                 return new UnionAsyncIteratorN<TSource>(_sources.Add(next), _headIndex + 1, _comparer);
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
     }
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Where.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Where.cs
index 705b07ac6..f4b96f071 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Where.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Where.cs
@@ -10,6 +10,10 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.where?view=net-9.0-pp#system-linq-asyncenumerable-where-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-boolean)))
+
         /// <summary>
         /// Filters the elements of an async-enumerable sequence based on a predicate.
         /// </summary>
@@ -34,6 +38,8 @@ public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSo
             return new WhereEnumerableAsyncIterator<TSource>(source, predicate);
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.where?view=net-9.0-pp#system-linq-asyncenumerable-where-1(system-collections-generic-iasyncenumerable((-0))-system-func((-0-system-int32-system-boolean)))
+
         /// <summary>
         /// Filters the elements of an async-enumerable sequence based on a predicate by incorporating the element's index.
         /// </summary>
@@ -69,6 +75,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
                 }
             }
         }
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
 
         /// <summary>
         /// Filters the elements of an async-enumerable sequence based on an asynchronous predicate.
@@ -79,6 +86,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
         /// <returns>An async-enumerable sequence that contains elements from the input sequence that satisfy the condition.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the WhereAwait functionality now exists as overloads of Where.")]
         private static IAsyncEnumerable<TSource> WhereAwaitCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -97,6 +105,7 @@ private static IAsyncEnumerable<TSource> WhereAwaitCore<TSource>(this IAsyncEnum
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the WhereAwaitWithCancellation functionality now exists as overloads of Where.")]
         private static IAsyncEnumerable<TSource> WhereAwaitWithCancellationCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -123,6 +132,7 @@ private static IAsyncEnumerable<TSource> WhereAwaitWithCancellationCore<TSource>
         /// <returns>An async-enumerable sequence that contains elements from the input sequence that satisfy the condition.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the WhereAwait functionality now exists as overloads of Where.")]
         private static IAsyncEnumerable<TSource> WhereAwaitCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
         {
             if (source == null)
@@ -153,6 +163,7 @@ static async IAsyncEnumerable<TSource> Core(IAsyncEnumerable<TSource> source, Fu
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the WhereAwaitWithCancellation functionality now exists as overloads of Where.")]
         private static IAsyncEnumerable<TSource> WhereAwaitWithCancellationCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs
index ec2a49f0d..f6f8ca228 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs
@@ -10,6 +10,19 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
+#if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.zip?view=net-9.0-pp#system-linq-asyncenumerable-zip-2(system-collections-generic-iasyncenumerable((-0))-system-collections-generic-iasyncenumerable((-1)))
+
+        /// <summary>
+        /// Merges two async-enumerable sequences into one async-enumerable sequence by combining their elements in a pairwise fashion.
+        /// </summary>
+        /// <typeparam name="TFirst">The type of the elements in the first source sequence.</typeparam>
+        /// <typeparam name="TSecond">The type of the elements in the second source sequence.</typeparam>
+        /// <typeparam name="TResult">The type of the elements in the result sequence, returned by the selector function.</typeparam>
+        /// <param name="first">First async-enumerable source.</param>
+        /// <param name="second">Second async-enumerable source.</param>
+        /// <returns>An async-enumerable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="selector"/> is null.</exception>
         public static IAsyncEnumerable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second)
         {
             if (first == null)
@@ -31,6 +44,8 @@ public static partial class AsyncEnumerable
             }
         }
 
+        // https://learn.microsoft.com/en-us/dotnet/api/system.linq.asyncenumerable.zip?view=net-9.0-pp#system-linq-asyncenumerable-zip-3(system-collections-generic-iasyncenumerable((-0))-system-collections-generic-iasyncenumerable((-1))-system-func((-0-1-2)))
+
         /// <summary>
         /// Merges two async-enumerable sequences into one async-enumerable sequence by combining their elements in a pairwise fashion.
         /// </summary>
@@ -65,6 +80,8 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TFirst> first, IAsy
             }
         }
 
+#endif // INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
+
         /// <summary>
         /// Merges two async-enumerable sequences into one async-enumerable sequence by combining their elements in a pairwise fashion.
         /// </summary>
@@ -77,6 +94,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TFirst> first, IAsy
         /// <returns>An async-enumerable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="selector"/> is null.</exception>
         [GenerateAsyncOverload]
+        [Obsolete("Use Zip. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ZipAwait functionality now exists as overloads of Zip.")]
         private static IAsyncEnumerable<TResult> ZipAwaitCore<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, ValueTask<TResult>> selector)
         {
             if (first == null)
@@ -102,6 +120,7 @@ static async IAsyncEnumerable<TResult> Core(IAsyncEnumerable<TFirst> first, IAsy
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Zip. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the ZipAwaitWithCancellation functionality now exists as overloads of Zip.")]
         private static IAsyncEnumerable<TResult> ZipAwaitWithCancellationCore<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, CancellationToken, ValueTask<TResult>> selector)
         {
             if (first == null)
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs
new file mode 100644
index 000000000..207f025e4
--- /dev/null
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs
@@ -0,0 +1,145 @@
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.ComVisible(false)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
+namespace System.Linq
+{
+    public static class AsyncEnumerableEx
+    {
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count, int skip) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TException, System.Collections.Generic.IAsyncEnumerable<TSource>> handler)
+            where TException : System.Exception { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TException, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> handler)
+            where TException : System.Exception { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TException, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> handler)
+            where TException : System.Exception { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Defer<TSource>(System.Func<System.Collections.Generic.IAsyncEnumerable<TSource>> factory) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Defer<TSource>(System.Func<System.Threading.Tasks.Task<System.Collections.Generic.IAsyncEnumerable<TSource>>> factory) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Defer<TSource>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<System.Collections.Generic.IAsyncEnumerable<TSource>>> factory) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.IObserver<TSource> observer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext, System.Action onCompleted) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext, System.Action<System.Exception> onError) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext, System.Func<System.Threading.Tasks.Task> onCompleted) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.Tasks.Task> onError) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext, System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> onCompleted) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task> onError) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.Tasks.Task> onError, System.Func<System.Threading.Tasks.Task> onCompleted) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task> onError, System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> onCompleted) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Expand<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TSource>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Expand<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Expand<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Finally<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action finallyAction) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Finally<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<System.Threading.Tasks.Task> finallyAction) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Generate<TState, TResult>(TState initialState, System.Func<TState, bool> condition, System.Func<TState, TState> iterate, System.Func<TState, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> IgnoreElements<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Threading.Tasks.ValueTask<bool> IsEmptyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Merge<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Merge<TSource>(this System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Merge<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TValue> Never<TValue>() { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Repeat<TResult>(TResult element) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Repeat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Repeat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Retry<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Retry<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int retryCount) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TValue> Return<TValue>(TValue value) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>> accumulator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, TSource> accumulator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>> accumulator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TOther> SelectMany<TSource, TOther>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IAsyncEnumerable<TOther> other) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> StartWith<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, params TSource[] values) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TValue> Throw<TValue>(System.Exception exception) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Timeout<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.TimeSpan timeout) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<System.Threading.Tasks.Task<TResource>> resourceFactory, System.Func<TResource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> enumerableFactory)
+            where TResource : System.IDisposable { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<TResource> resourceFactory, System.Func<TResource, System.Collections.Generic.IAsyncEnumerable<TSource>> enumerableFactory)
+            where TResource : System.IDisposable { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResource>> resourceFactory, System.Func<TResource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> enumerableFactory)
+            where TResource : System.IDisposable { }
+    }
+    public interface IAsyncIListProvider<TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
+    {
+        System.Threading.Tasks.ValueTask<int> GetCountAsync(bool onlyIfCheap, System.Threading.CancellationToken cancellationToken);
+        System.Threading.Tasks.ValueTask<TElement[]> ToArrayAsync(System.Threading.CancellationToken cancellationToken);
+        System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TElement>> ToListAsync(System.Threading.CancellationToken cancellationToken);
+    }
+}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs
new file mode 100644
index 000000000..55fa24db5
--- /dev/null
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs
@@ -0,0 +1,82 @@
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.ComVisible(false)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
+namespace System.Linq
+{
+    [System.Linq.LocalQueryMethodImplementationType(typeof(System.Linq.AsyncEnumerableEx))]
+    public static class AsyncQueryableEx
+    {
+        public static System.Linq.IAsyncQueryable<TSource> Amb<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Linq.IAsyncQueryable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
+        public static System.Linq.IAsyncQueryable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count, int skip) { }
+        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource, TException>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.Collections.Generic.IAsyncEnumerable<TSource>>> handler) { }
+        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource, TException>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> handler) { }
+        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource, TException>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> handler) { }
+        public static System.Linq.IAsyncQueryable<TSource> Concat<TSource>(this System.Linq.IAsyncQueryable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.IObserver<TSource> observer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext, System.Action onCompleted) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext, System.Linq.Expressions.Expression<System.Action<System.Exception>> onError) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Threading.Tasks.Task>> onCompleted) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.Tasks.Task>> onError) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task>> onCompleted) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onError) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext, System.Linq.Expressions.Expression<System.Action<System.Exception>> onError, System.Action onCompleted) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.Tasks.Task>> onError, System.Linq.Expressions.Expression<System.Func<System.Threading.Tasks.Task>> onCompleted) { }
+        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onError, System.Linq.Expressions.Expression<System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task>> onCompleted) { }
+        public static System.Linq.IAsyncQueryable<TSource> Expand<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TSource>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TSource> Expand<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TSource> Expand<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TSource> Finally<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Action finallyAction) { }
+        public static System.Linq.IAsyncQueryable<TSource> Finally<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<System.Threading.Tasks.Task>> finallyAction) { }
+        public static System.Linq.IAsyncQueryable<TSource> IgnoreElements<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Threading.Tasks.ValueTask<bool> IsEmptyAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> Merge<TSource>(this System.Linq.IAsyncQueryable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> OnErrorResumeNext<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Linq.IAsyncQueryable<TSource> Repeat<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Linq.IAsyncQueryable<TSource> Repeat<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
+        public static System.Linq.IAsyncQueryable<TSource> Retry<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Linq.IAsyncQueryable<TSource> Retry<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int retryCount) { }
+        public static System.Linq.IAsyncQueryable<TSource> Scan<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>>> accumulator) { }
+        public static System.Linq.IAsyncQueryable<TSource> Scan<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, TSource>> accumulator) { }
+        public static System.Linq.IAsyncQueryable<TSource> Scan<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>>> accumulator) { }
+        public static System.Linq.IAsyncQueryable<TAccumulate> Scan<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator) { }
+        public static System.Linq.IAsyncQueryable<TAccumulate> Scan<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator) { }
+        public static System.Linq.IAsyncQueryable<TAccumulate> Scan<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator) { }
+        public static System.Linq.IAsyncQueryable<TOther> SelectMany<TSource, TOther>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IAsyncEnumerable<TOther> other) { }
+        public static System.Linq.IAsyncQueryable<TSource> StartWith<TSource>(this System.Linq.IAsyncQueryable<TSource> source, params TSource[] values) { }
+        public static System.Linq.IAsyncQueryable<TSource> Timeout<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.TimeSpan timeout) { }
+    }
+}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs
new file mode 100644
index 000000000..e19c26338
--- /dev/null
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs
@@ -0,0 +1,703 @@
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.ComVisible(false)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName=".NET Standard 2.1")]
+namespace System.Collections.Generic
+{
+    public static class AsyncEnumerator
+    {
+        public static System.Collections.Generic.IAsyncEnumerator<T> Create<T>(System.Func<System.Threading.Tasks.ValueTask<bool>> moveNextAsync, System.Func<T> getCurrent, System.Func<System.Threading.Tasks.ValueTask> disposeAsync) { }
+        public static System.Threading.Tasks.ValueTask<bool> MoveNextAsync<T>(this System.Collections.Generic.IAsyncEnumerator<T> source, System.Threading.CancellationToken cancellationToken) { }
+        public static System.Collections.Generic.IAsyncEnumerator<T> WithCancellation<T>(this System.Collections.Generic.IAsyncEnumerator<T> source, System.Threading.CancellationToken cancellationToken) { }
+    }
+}
+namespace System.Linq
+{
+    public static class AsyncEnumerable
+    {
+        public static System.Threading.Tasks.ValueTask<TSource> AggregateAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, TSource> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Func<TAccumulate, TResult> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitAsync now exists as overloads of AggregateAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitAsync functionality now exists as overloads of AggregateAs" +
+            "ync.")]
+        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitAsync functionality now exists as overloads of AggregateAs" +
+            "ync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Func<TAccumulate, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of AggregateAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of AggregateAsync.")]
+        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of AggregateAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Func<TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AllAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AllAwaitAsync functionality now exists as overloads of All.")]
+        public static System.Threading.Tasks.ValueTask<bool> AllAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AllAwaitWithCancellationAsync functionality now exists as overloads of AllAsyn" +
+            "c.")]
+        public static System.Threading.Tasks.ValueTask<bool> AllAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AnyAwaitAsync functionality now exists as overloads of AnyAsync.")]
+        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AnyAwaitWithCancellationAsync functionality now exists as overloads of AnyAsyn" +
+            "c.")]
+        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Append<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource element) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Cast<TResult>(this System.Collections.Generic.IAsyncEnumerable<object> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource value, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the CountAwaitAsync functionality now exists as overloads of CountAsync.")]
+        public static System.Threading.Tasks.ValueTask<int> CountAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the CountAwaitWithCancellationAsync functionality now exists as overloads of Cou" +
+            "ntAsync.")]
+        public static System.Threading.Tasks.ValueTask<int> CountAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<T> Create<T>(System.Func<System.Threading.CancellationToken, System.Collections.Generic.IAsyncEnumerator<T>> getAsyncEnumerator) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource defaultValue) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource> ElementAtAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> ElementAtOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TValue> Empty<TValue>() { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the FirstAwaitAsync functionality now exists as overloads of FirstAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the FirstAwaitWithCancellationAsync functionality now exists as overloads of Fir" +
+            "stAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumera" +
+            "ble, and the FirstOrDefaultAwaitAsync functionality now exists as overloads of F" +
+            "irstOrDefaultAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumera" +
+            "ble, and the FirstOrDefaultAwaitWithCancellationAsync functionality now exists a" +
+            "s overloads of FirstOrDefaultAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
+        public static System.Threading.Tasks.Task ForEachAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
+        public static System.Threading.Tasks.Task ForEachAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource, int> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
+        public static System.Threading.Tasks.Task ForEachAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
+        public static System.Threading.Tasks.Task ForEachAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
+        public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
+        public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken) { }
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwaitWithCancellation functionality now exists as overloads of Group" +
+            "Join.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwaitWithCancellation functionality now exists as overloads of Group" +
+            "Join.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwait functionality now exists as overloads of Join.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwait functionality now exists as overloads of Join.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwaitWithCancellation functionality now exists as overloads of Join.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwaitWithCancellation functionality now exists as overloads of Join.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he LastAwaitAsync functionality now exists as overloads of LastAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he LastAwaitWithCancellationAsync functionality now exists as overloads of LastA" +
+            "sync.")]
+        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerab" +
+            "le, and the LastOrDefaultAwaitAsync functionality now exists as overloads of Las" +
+            "tOrDefaultAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerab" +
+            "le, and the LastOrDefaultAwaitWithCancellationAsync functionality now exists as " +
+            "overloads of LastOrDefaultAsync.")]
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the LongCountAwaitAsync functionality now exists as overloads of LongCountAs" +
+            "ync.")]
+        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the LongCountAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of LongCountAsync.")]
+        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by the MaxAsync overload that took a selec" +
+            "tor callback now exists as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> MaxAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MinAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MinAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MinAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MinAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MinAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by the MinAsync overload that took a selec" +
+            "tor callback now exists as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> MinAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<double?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<float?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<int?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<long?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
+        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> OfType<TResult>(this System.Collections.Generic.IAsyncEnumerable<object?> source) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Prepend<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource element) { }
+        public static System.Collections.Generic.IAsyncEnumerable<int> Range(int start, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Repeat<TResult>(TResult element, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Reverse<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, TResult> selector) { }
+        [System.Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he AggregateAwait and AggregateAwaitWithCancellationAsync functionality now exis" +
+            "ts as overloads of Aggregate.")]
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Skip<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Take<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource[]> ToArrayAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.IObservable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.Threading.Tasks.Task<TSource> task) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Collections.Generic.IEnumerable<TSource> ToEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TSource>> ToListAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.IObservable<TSource> ToObservable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "First",
+                "Second"})]
+        public static System.Collections.Generic.IAsyncEnumerable<System.ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, TResult> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> ZipAwait<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+    }
+    public interface IAsyncGrouping<out TKey, out TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
+    {
+        TKey Key { get; }
+    }
+    [System.Obsolete("Use the definition of this type in the System.Interactive.Async NuGet package Sys" +
+        "tem.Linq.Async instead.")]
+    public interface IAsyncIListProvider<TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
+    {
+        System.Threading.Tasks.ValueTask<int> GetCountAsync(bool onlyIfCheap, System.Threading.CancellationToken cancellationToken);
+        System.Threading.Tasks.ValueTask<TElement[]> ToArrayAsync(System.Threading.CancellationToken cancellationToken);
+        System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TElement>> ToListAsync(System.Threading.CancellationToken cancellationToken);
+    }
+    public interface IOrderedAsyncEnumerable<out TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
+    {
+        System.Linq.IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, bool descending);
+        System.Linq.IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, bool descending);
+        System.Linq.IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, bool descending);
+    }
+}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs
new file mode 100644
index 000000000..33196b616
--- /dev/null
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs
@@ -0,0 +1,413 @@
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.ComVisible(false)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName=".NET Standard 2.1")]
+namespace System.Linq
+{
+    public static class AsyncQueryable
+    {
+        public static System.Threading.Tasks.ValueTask<TSource> AggregateAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AllAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AllAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AllAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> Append<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource element) { }
+        public static System.Linq.IAsyncQueryable<TElement> AsAsyncQueryable<TElement>(this System.Collections.Generic.IAsyncEnumerable<TElement> source) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TResult> Cast<TResult>(this System.Linq.IAsyncQueryable<object> source) { }
+        public static System.Linq.IAsyncQueryable<TSource> Concat<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource value, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> CountAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> CountAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Linq.IAsyncQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource defaultValue) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource> ElementAtAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> ElementAtOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> Except<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Linq.IAsyncQueryable<TSource> Except<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Intersect<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Linq.IAsyncQueryable<TSource> Intersect<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MaxAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MaxAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MaxAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MaxAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MaxAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MaxAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MaxAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MaxAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> MaxAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MinAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MinAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MinAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MinAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MinAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MinAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MinAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MinAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MinAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> MinAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TResult> OfType<TResult>(this System.Linq.IAsyncQueryable<object?> source) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Prepend<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource element) { }
+        public static System.Linq.IAsyncQueryable<TSource> Reverse<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
+        public static System.Linq.IAsyncQueryable<TResult> Select<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> Select<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, TResult>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
+        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> Skip<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipLast<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<int?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<long?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> Take<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeLast<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
+        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
+        public static System.Threading.Tasks.ValueTask<TSource[]> ToArrayAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
+            where TKey :  notnull { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TSource>> ToListAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Linq.IAsyncQueryable<TSource> Union<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Linq.IAsyncQueryable<TSource> Union<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
+        public static System.Linq.IAsyncQueryable<TSource> Where<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> Where<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> WhereAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> WhereAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> WhereAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<TSource> WhereAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
+        public static System.Linq.IAsyncQueryable<System.ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second) { }
+        public static System.Linq.IAsyncQueryable<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, TResult>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> ZipAwait<TFirst, TSecond, TResult>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
+        public static System.Linq.IAsyncQueryable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
+    }
+    public interface IAsyncQueryProvider
+    {
+        System.Linq.IAsyncQueryable<TElement> CreateQuery<TElement>(System.Linq.Expressions.Expression expression);
+        System.Threading.Tasks.ValueTask<TResult> ExecuteAsync<TResult>(System.Linq.Expressions.Expression expression, System.Threading.CancellationToken token);
+    }
+    public interface IAsyncQueryable
+    {
+        System.Type ElementType { get; }
+        System.Linq.Expressions.Expression Expression { get; }
+        System.Linq.IAsyncQueryProvider Provider { get; }
+    }
+    public interface IAsyncQueryable<out T> : System.Collections.Generic.IAsyncEnumerable<T>, System.Linq.IAsyncQueryable { }
+    public interface IOrderedAsyncQueryable : System.Linq.IAsyncQueryable { }
+    public interface IOrderedAsyncQueryable<out T> : System.Collections.Generic.IAsyncEnumerable<T>, System.Linq.IAsyncQueryable, System.Linq.IAsyncQueryable<T>, System.Linq.IOrderedAsyncQueryable { }
+    [System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
+    public sealed class LocalQueryMethodImplementationTypeAttribute : System.Attribute
+    {
+        public LocalQueryMethodImplementationTypeAttribute(System.Type targetType) { }
+        public System.Type TargetType { get; }
+    }
+}
\ No newline at end of file

From 8cbb5a5bfacc0ec8491c971e7e7bce611c6ac075 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 13:57:42 +0100
Subject: [PATCH 06/10] Update pipeline to use .NET 10.0 SDK

---
 azure-pipelines.ix.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/azure-pipelines.ix.yml b/azure-pipelines.ix.yml
index 5940b7f1a..556b14360 100644
--- a/azure-pipelines.ix.yml
+++ b/azure-pipelines.ix.yml
@@ -32,14 +32,14 @@ stages:
       vmImage: windows-latest
     steps:
     - task: UseDotNet@2
-      displayName: Use .NET Core 8.x SDK
+      displayName: Use .NET Core 10.x SDK
       inputs:
-        version: 8.x
+        version: 10.x
 
     - task: UseDotNet@2
-      displayName: .NET 6.0 runtime
+      displayName: .NET 8.0 runtime
       inputs:
-        version: '6.x'
+        version: '8.x'
         packageType: runtime
 
     - task: DotNetCoreCLI@2

From 4fda8d09bd4901fc030952dd8b9c9f64701d0932 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 14:00:36 +0100
Subject: [PATCH 07/10] Set includePreviewVersions on .net 10 step

---
 azure-pipelines.ix.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/azure-pipelines.ix.yml b/azure-pipelines.ix.yml
index 556b14360..4f2e59ea8 100644
--- a/azure-pipelines.ix.yml
+++ b/azure-pipelines.ix.yml
@@ -35,6 +35,7 @@ stages:
       displayName: Use .NET Core 10.x SDK
       inputs:
         version: 10.x
+        includePreviewVersions: true
 
     - task: UseDotNet@2
       displayName: .NET 8.0 runtime

From 37a08e9a17440057f6c3b748c7ea4230d0ef08e1 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 15:56:46 +0100
Subject: [PATCH 08/10] Update approved APIs. Fix code gen discrepancies.

Fix erroneous doc comment on ZIP
---
 .../System/Linq/IAsyncIListProvider.cs        |    2 +-
 .../Linq/Operators/Average.Generated.cs       | 1212 ++---------------
 .../Linq/Operators/Average.Generated.tt       |  163 ---
 .../System/Linq/IAsyncIListProvider.cs        |    2 +-
 .../Linq/Operators/Average.Generated.cs       |   40 +-
 .../Linq/Operators/Average.Generated.tt       |    4 +-
 .../System/Linq/Operators/Sum.Generated.cs    |   60 +-
 .../System/Linq/Operators/Sum.Generated.tt    |    6 +-
 .../System/Linq/Operators/Zip.cs              |    3 +-
 ...alTests.SystemInteractiveAsync.received.cs |  145 --
 ...alTests.SystemInteractiveAsync.verified.cs |   16 +-
 ...ystemInteractiveAsyncProviders.received.cs |   82 --
 ...ystemInteractiveAsyncProviders.verified.cs |    2 +-
 ...iApprovalTests.SystemLinqAsync.received.cs |  703 ----------
 ...iApprovalTests.SystemLinqAsync.verified.cs |  479 ++++++-
 ...Tests.SystemLinqAsyncQueryable.received.cs |  413 ------
 ...Tests.SystemLinqAsyncQueryable.verified.cs |    2 +-
 17 files changed, 726 insertions(+), 2608 deletions(-)
 delete mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs
 delete mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs
 delete mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs
 delete mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs

diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs
index 052ba2b51..717dce945 100644
--- a/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/IAsyncIListProvider.cs
@@ -24,7 +24,7 @@ namespace System.Linq
     /// the old version defined in the deprecated <c>System.Linq.Async</c> package) will continue to provide the
     /// same (unsupported) behaviour.
     /// </remarks>
-    public interface IAsyncIListProvider<TElement> : IAsyncEnumerable<TElement>
+    internal interface IAsyncIListProvider<TElement> : IAsyncEnumerable<TElement>
     {
         /// <summary>
         /// Produce an array of the sequence through an optimized path.
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs
index a8cfe864a..cb32b4639 100644
--- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.cs
@@ -56,914 +56,9 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    long sum = await selector(e.Current).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return (double)sum / count;
-                }
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    long sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return (double)sum / count;
-                }
-            }
-        }
-#endif
-
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values to calculate the average of.</param>
-        /// <param name="selector">A transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    long sum = selector(e.Current);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += selector(e.Current);
-                            ++count;
-                        }
-                    }
-
-                    return (double)sum / count;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    long sum = await selector(e.Current).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return (double)sum / count;
-                }
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    long sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return (double)sum / count;
-                }
-            }
-        }
-#endif
-
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values to calculate the average of.</param>
-        /// <param name="selector">A transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<float> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    double sum = selector(e.Current);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += selector(e.Current);
-                            ++count;
-                        }
-                    }
-
-                    return (float)(sum / count);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<float> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    double sum = await selector(e.Current).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return (float)(sum / count);
-                }
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<float> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    double sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return (float)(sum / count);
-                }
-            }
-        }
-#endif
-
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values to calculate the average of.</param>
-        /// <param name="selector">A transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    double sum = selector(e.Current);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += selector(e.Current);
-                            ++count;
-                        }
-                    }
-
-                    return sum / count;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    double sum = await selector(e.Current).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return sum / count;
-                }
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    double sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return sum / count;
-                }
-            }
-        }
-#endif
-
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="decimal" /> values that are obtained by invoking a transform function on each element of the input sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values to calculate the average of.</param>
-        /// <param name="selector">A transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<decimal> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    decimal sum = selector(e.Current);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += selector(e.Current);
-                            ++count;
-                        }
-                    }
-
-                    return sum / count;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    decimal sum = await selector(e.Current).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return sum / count;
-                }
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    decimal sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return sum / count;
-                }
-            }
-        }
-#endif
-
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Int}" /> values that are obtained by invoking a transform function on each element of the input sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values to calculate the average of.</param>
-        /// <param name="selector">A transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = selector(e.Current);
-                        if (v.HasValue)
-                        {
-                            long sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = selector(e.Current);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return (double)sum / count;
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = await selector(e.Current).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            long sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return (double)sum / count;
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            long sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return (double)sum / count;
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-#endif
-
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Long}" /> values that are obtained by invoking a transform function on each element of the input sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <param name="source">A sequence of values to calculate the average of.</param>
-        /// <param name="selector">A transform function to apply to each element.</param>
-        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
-        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = selector(e.Current);
-                        if (v.HasValue)
-                        {
-                            long sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = selector(e.Current);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return (double)sum / count;
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = await selector(e.Current).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            long sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return (double)sum / count;
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken)
-            {
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            long sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return (double)sum / count;
-                        }
-                    }
-                }
-
-                return null;
-            }
-        }
-#endif
-
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Float}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an async-enumerable sequence of <see cref="long" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -973,7 +68,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<float?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -982,52 +77,44 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, long> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
-                    while (await e.MoveNextAsync())
+                    if (!await e.MoveNextAsync())
                     {
-                        var v = selector(e.Current);
-                        if (v.HasValue)
-                        {
-                            double sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = selector(e.Current);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
+                        throw Error.NoElements();
+                    }
 
-                            return (float)(sum / count);
+                    long sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
                         }
                     }
-                }
 
-                return null;
+                    return (double)sum / count;
+                }
             }
         }
 
+
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="float" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<float?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1036,42 +123,44 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken)
+            static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSource, float> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
-                    while (await e.MoveNextAsync())
+                    if (!await e.MoveNextAsync())
                     {
-                        var v = await selector(e.Current).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            double sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
+                        throw Error.NoElements();
+                    }
 
-                            return (float)(sum / count);
+                    double sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
                         }
                     }
-                }
 
-                return null;
+                    return (float)(sum / count);
+                }
             }
         }
 
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<float?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="double" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1080,43 +169,34 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken)
+            static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSource, double> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
-                    while (await e.MoveNextAsync())
+                    if (!await e.MoveNextAsync())
                     {
-                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            double sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
+                        throw Error.NoElements();
+                    }
 
-                            return (float)(sum / count);
+                    double sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
                         }
                     }
-                }
 
-                return null;
+                    return sum / count;
+                }
             }
         }
-#endif
 
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Double}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an async-enumerable sequence of <see cref="decimal" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -1126,7 +206,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1135,52 +215,44 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
+            static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSource, decimal> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
-                    while (await e.MoveNextAsync())
+                    if (!await e.MoveNextAsync())
                     {
-                        var v = selector(e.Current);
-                        if (v.HasValue)
-                        {
-                            double sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = selector(e.Current);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
+                        throw Error.NoElements();
+                    }
 
-                            return sum / count;
+                    decimal sum = selector(e.Current);
+                    long count = 1;
+                    checked
+                    {
+                        while (await e.MoveNextAsync())
+                        {
+                            sum += selector(e.Current);
+                            ++count;
                         }
                     }
-                }
 
-                return null;
+                    return sum / count;
+                }
             }
         }
 
+
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Int}" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1189,22 +261,22 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken)
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, int?> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
                     while (await e.MoveNextAsync())
                     {
-                        var v = await selector(e.Current).ConfigureAwait(false);
+                        var v = selector(e.Current);
                         if (v.HasValue)
                         {
-                            double sum = v.GetValueOrDefault();
+                            long sum = v.GetValueOrDefault();
                             long count = 1;
                             checked
                             {
                                 while (await e.MoveNextAsync())
                                 {
-                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    v = selector(e.Current);
                                     if (v.HasValue)
                                     {
                                         sum += v.GetValueOrDefault();
@@ -1213,7 +285,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                                 }
                             }
 
-                            return sum / count;
+                            return (double)sum / count;
                         }
                     }
                 }
@@ -1222,9 +294,19 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Long}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1233,22 +315,22 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken)
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, long?> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
                     while (await e.MoveNextAsync())
                     {
-                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        var v = selector(e.Current);
                         if (v.HasValue)
                         {
-                            double sum = v.GetValueOrDefault();
+                            long sum = v.GetValueOrDefault();
                             long count = 1;
                             checked
                             {
                                 while (await e.MoveNextAsync())
                                 {
-                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    v = selector(e.Current);
                                     if (v.HasValue)
                                     {
                                         sum += v.GetValueOrDefault();
@@ -1257,7 +339,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                                 }
                             }
 
-                            return sum / count;
+                            return (double)sum / count;
                         }
                     }
                 }
@@ -1265,11 +347,10 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
-#endif
 
 
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Float}" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
         /// <param name="source">A sequence of values to calculate the average of.</param>
@@ -1279,7 +360,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
         /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        public static ValueTask<decimal?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1288,7 +369,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
+            static async ValueTask<float?> Core(IAsyncEnumerable<TSource> source, Func<TSource, float?> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
@@ -1297,7 +378,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                         var v = selector(e.Current);
                         if (v.HasValue)
                         {
-                            decimal sum = v.GetValueOrDefault();
+                            double sum = v.GetValueOrDefault();
                             long count = 1;
                             checked
                             {
@@ -1312,7 +393,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                                 }
                             }
 
-                            return sum / count;
+                            return (float)(sum / count);
                         }
                     }
                 }
@@ -1321,19 +402,19 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
+
         /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Double}" /> values that are obtained by invoking a transform function on each element of the input sequence.
         /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1342,22 +423,22 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken)
+            static async ValueTask<double?> Core(IAsyncEnumerable<TSource> source, Func<TSource, double?> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
                     while (await e.MoveNextAsync())
                     {
-                        var v = await selector(e.Current).ConfigureAwait(false);
+                        var v = selector(e.Current);
                         if (v.HasValue)
                         {
-                            decimal sum = v.GetValueOrDefault();
+                            double sum = v.GetValueOrDefault();
                             long count = 1;
                             checked
                             {
                                 while (await e.MoveNextAsync())
                                 {
-                                    v = await selector(e.Current).ConfigureAwait(false);
+                                    v = selector(e.Current);
                                     if (v.HasValue)
                                     {
                                         sum += v.GetValueOrDefault();
@@ -1375,9 +456,19 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<decimal?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+
+        /// <summary>
+        /// Computes the average of an async-enumerable sequence of <see cref="Nullable{Decimal}" /> values that are obtained by invoking a transform function on each element of the input sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+        /// <param name="source">A sequence of values to calculate the average of.</param>
+        /// <param name="selector">A transform function to apply to each element.</param>
+        /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
+        /// <returns>An async-enumerable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">(Asynchronous) The source sequence is empty.</exception>
+        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
+        public static ValueTask<decimal?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1386,13 +477,13 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
             return Core(source, selector, cancellationToken);
 
-            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken)
+            static async ValueTask<decimal?> Core(IAsyncEnumerable<TSource> source, Func<TSource, decimal?> selector, CancellationToken cancellationToken)
             {
                 await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
                 {
                     while (await e.MoveNextAsync())
                     {
-                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                        var v = selector(e.Current);
                         if (v.HasValue)
                         {
                             decimal sum = v.GetValueOrDefault();
@@ -1401,7 +492,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                             {
                                 while (await e.MoveNextAsync())
                                 {
-                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
+                                    v = selector(e.Current);
                                     if (v.HasValue)
                                     {
                                         sum += v.GetValueOrDefault();
@@ -1418,7 +509,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
-#endif
 
     }
 }
diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt
index 499c04e97..7ab5cfa74 100644
--- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt
+++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Average.Generated.tt
@@ -148,169 +148,6 @@ else
             }
         }
 
-        /// <summary>
-        /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
-        /// </summary>
-        /// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
-        /// <param name="source">An async-enumerable sequence of values to compute the average of.</param>
-        /// <param name="selector">A transform function to invoke and await on each element of the source sequence.</param>
-        /// <param name="cancellationToken">An optional cancellation token for cancelling the sequence at any time.</param>
-        /// <returns>A ValueTask containing the average of the sequence of values.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
-        /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
-        /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
-        [GenerateAsyncOverload]
-        private static ValueTask<<#=o.res#>> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<<#=o.res#>> Core(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken)
-            {
-<#
-if (isNullable)
-{
-#>
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = await selector(e.Current).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            <#=o.sum#> sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return <#=res#>;
-                        }
-                    }
-                }
-
-                return null;
-<#
-}
-else
-{
-#>
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    <#=o.sum#> sum = await selector(e.Current).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return <#=res#>;
-                }
-<#
-}
-#>
-            }
-        }
-
-#if !NO_DEEP_CANCELLATION
-        [GenerateAsyncOverload]
-        private static ValueTask<<#=o.res#>> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
-        {
-            if (source == null)
-                throw Error.ArgumentNull(nameof(source));
-            if (selector == null)
-                throw Error.ArgumentNull(nameof(selector));
-
-            return Core(source, selector, cancellationToken);
-
-            static async ValueTask<<#=o.res#>> Core(IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken)
-            {
-<#
-if (isNullable)
-{
-#>
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    while (await e.MoveNextAsync())
-                    {
-                        var v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                        if (v.HasValue)
-                        {
-                            <#=o.sum#> sum = v.GetValueOrDefault();
-                            long count = 1;
-                            checked
-                            {
-                                while (await e.MoveNextAsync())
-                                {
-                                    v = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                                    if (v.HasValue)
-                                    {
-                                        sum += v.GetValueOrDefault();
-                                        ++count;
-                                    }
-                                }
-                            }
-
-                            return <#=res#>;
-                        }
-                    }
-                }
-
-                return null;
-<#
-}
-else
-{
-#>
-                await using (var e = source.GetConfiguredAsyncEnumerator(cancellationToken, false))
-                {
-                    if (!await e.MoveNextAsync())
-                    {
-                        throw Error.NoElements();
-                    }
-
-                    <#=o.sum#> sum = await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                    long count = 1;
-                    checked
-                    {
-                        while (await e.MoveNextAsync())
-                        {
-                            sum += await selector(e.Current, cancellationToken).ConfigureAwait(false);
-                            ++count;
-                        }
-                    }
-
-                    return <#=res#>;
-                }
-<#
-}
-#>
-            }
-        }
-#endif
-
 <#
 }
 #>
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs
index ee053df3d..f303daad8 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/IAsyncIListProvider.cs
@@ -19,7 +19,7 @@ namespace System.Linq
     /// its own version of this interface. We can't replace this with a type forwarder here because that would risk creating a
     /// circular dependency in cases where an application managed to get out-of-sync versions of the two packages.
     /// </remarks>
-    [Obsolete("Use the definition of this type in the System.Interactive.Async NuGet package System.Linq.Async instead.")] // Can't use a type forwarder because 
+    [Obsolete("This interface was always unsupported, and the IAsyncEnumerable<T> LINQ implementation in System.Linq.AsyncEnumerable does not recognize it, so this no longer serves a purpose")]
     public interface IAsyncIListProvider<TElement> : IAsyncEnumerable<TElement>
     {
         /// <summary>
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs
index 0081d23b2..7c2581710 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs
@@ -95,6 +95,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
                 }
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -108,6 +109,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -144,6 +146,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -178,7 +181,6 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -265,6 +267,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
                 }
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -278,6 +281,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -314,6 +318,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -348,7 +353,6 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -435,6 +439,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
                 }
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -448,6 +453,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<float> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -484,6 +490,7 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<float> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -518,7 +525,6 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -605,6 +611,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
                 }
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -618,6 +625,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -654,6 +662,7 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -688,7 +697,6 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -775,6 +783,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 }
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -788,6 +797,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<decimal> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -824,6 +834,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<decimal> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -858,7 +869,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -961,6 +971,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -974,6 +985,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1018,6 +1030,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1060,7 +1073,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -1163,6 +1175,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -1176,6 +1189,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1220,6 +1234,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1262,7 +1277,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -1365,6 +1379,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -1378,6 +1393,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<float?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1422,6 +1438,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<float?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1464,7 +1481,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -1567,6 +1583,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -1580,6 +1597,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1624,6 +1642,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<double?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1666,7 +1685,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
             }
         }
 #endif
-#endif
 
 #if INCLUDE_SYSTEM_LINQ_ASYNCENUMERABLE_DUPLICATES
         /// <summary>
@@ -1769,6 +1787,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -1782,6 +1801,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<decimal?> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1826,6 +1846,7 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<decimal?> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -1867,7 +1888,6 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
                 return null;
             }
         }
-#endif
 #endif
 
     }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt
index 4d5a50834..a7e193174 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt
@@ -215,6 +215,7 @@ else
 #>
             }
         }
+#endif
 
         /// <summary>
         /// Computes the average of an async-enumerable sequence of <see cref="int"/> values that are obtained by invoking an asynchronous transform function on each element of the source sequence and awaiting the result.
@@ -228,6 +229,7 @@ else
         /// <exception cref="InvalidOperationException">The source sequence is empty.</exception>
         /// <remarks>The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior.</remarks>
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<<#=o.res#>> AverageAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -304,6 +306,7 @@ else
 
 #if !NO_DEEP_CANCELLATION
         [GenerateAsyncOverload]
+        [Obsolete("Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         private static ValueTask<<#=o.res#>> AverageAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
@@ -378,7 +381,6 @@ else
             }
         }
 #endif
-#endif
 
 <#
 }
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs
index 9829a4f90..bd9000a0c 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs
@@ -82,7 +82,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<int> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<int> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -111,7 +112,8 @@ static async ValueTask<int> Core(IAsyncEnumerable<TSource> source, Func<TSource,
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<int> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<int> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -211,7 +213,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<long> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<long> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -240,7 +243,8 @@ static async ValueTask<long> Core(IAsyncEnumerable<TSource> source, Func<TSource
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<long> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<long> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -334,7 +338,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<float> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<float> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -360,7 +365,8 @@ static async ValueTask<float> Core(IAsyncEnumerable<TSource> source, Func<TSourc
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<float> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<float> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -451,7 +457,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<double> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<double> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -477,7 +484,8 @@ static async ValueTask<double> Core(IAsyncEnumerable<TSource> source, Func<TSour
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<double> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<double> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -568,7 +576,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<decimal> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -594,7 +603,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<decimal> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -691,7 +701,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<int?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<int?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -720,7 +731,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<int?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<int?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -820,7 +832,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<long?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<long?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -849,7 +862,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<long?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<long?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -943,7 +957,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<float?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<float?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -969,7 +984,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<float?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<float?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1060,7 +1076,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<double?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1086,7 +1103,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<double?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<double?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1177,7 +1195,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<decimal?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal?> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1203,7 +1222,8 @@ static async ValueTask<decimal> Core(IAsyncEnumerable<TSource> source, Func<TSou
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<decimal?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<decimal?> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt
index c2866e384..a24268e63 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt
@@ -138,7 +138,8 @@ else
         }
 
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<<#=o.type#>> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<<#=o.type#>> SumAwaitAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -180,7 +181,8 @@ else
 
 #if !NO_DEEP_CANCELLATION
         [Obsolete("Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
-        internal static ValueTask<<#=o.type#>> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        [GenerateAsyncOverload]
+        private static ValueTask<<#=o.type#>> SumAwaitWithCancellationAsyncCore<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs
index f6f8ca228..6e06fb369 100644
--- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs
+++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs
@@ -18,11 +18,10 @@ public static partial class AsyncEnumerable
         /// </summary>
         /// <typeparam name="TFirst">The type of the elements in the first source sequence.</typeparam>
         /// <typeparam name="TSecond">The type of the elements in the second source sequence.</typeparam>
-        /// <typeparam name="TResult">The type of the elements in the result sequence, returned by the selector function.</typeparam>
         /// <param name="first">First async-enumerable source.</param>
         /// <param name="second">Second async-enumerable source.</param>
         /// <returns>An async-enumerable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="selector"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
         public static IAsyncEnumerable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second)
         {
             if (first == null)
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs
deleted file mode 100644
index 207f025e4..000000000
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.received.cs
+++ /dev/null
@@ -1,145 +0,0 @@
-[assembly: System.CLSCompliant(true)]
-[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
-[assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
-namespace System.Linq
-{
-    public static class AsyncEnumerableEx
-    {
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count, int skip) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TException, System.Collections.Generic.IAsyncEnumerable<TSource>> handler)
-            where TException : System.Exception { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TException, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> handler)
-            where TException : System.Exception { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource, TException>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TException, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> handler)
-            where TException : System.Exception { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Defer<TSource>(System.Func<System.Collections.Generic.IAsyncEnumerable<TSource>> factory) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Defer<TSource>(System.Func<System.Threading.Tasks.Task<System.Collections.Generic.IAsyncEnumerable<TSource>>> factory) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Defer<TSource>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<System.Collections.Generic.IAsyncEnumerable<TSource>>> factory) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.IObserver<TSource> observer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext, System.Action onCompleted) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext, System.Action<System.Exception> onError) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext, System.Func<System.Threading.Tasks.Task> onCompleted) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.Tasks.Task> onError) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext, System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> onCompleted) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task> onError) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.Tasks.Task> onError, System.Func<System.Threading.Tasks.Task> onCompleted) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Do<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> onNext, System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task> onError, System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> onCompleted) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Expand<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TSource>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Expand<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Expand<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Finally<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action finallyAction) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Finally<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<System.Threading.Tasks.Task> finallyAction) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Generate<TState, TResult>(TState initialState, System.Func<TState, bool> condition, System.Func<TState, TState> iterate, System.Func<TState, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> IgnoreElements<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Threading.Tasks.ValueTask<bool> IsEmptyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Merge<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Merge<TSource>(this System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Merge<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TValue> Never<TValue>() { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> OnErrorResumeNext<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Repeat<TResult>(TResult element) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Repeat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Repeat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Retry<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Retry<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int retryCount) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TValue> Return<TValue>(TValue value) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>> accumulator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, TSource> accumulator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Scan<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>> accumulator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TAccumulate> Scan<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TOther> SelectMany<TSource, TOther>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IAsyncEnumerable<TOther> other) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> StartWith<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, params TSource[] values) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TValue> Throw<TValue>(System.Exception exception) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Timeout<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.TimeSpan timeout) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<System.Threading.Tasks.Task<TResource>> resourceFactory, System.Func<TResource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> enumerableFactory)
-            where TResource : System.IDisposable { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<TResource> resourceFactory, System.Func<TResource, System.Collections.Generic.IAsyncEnumerable<TSource>> enumerableFactory)
-            where TResource : System.IDisposable { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResource>> resourceFactory, System.Func<TResource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> enumerableFactory)
-            where TResource : System.IDisposable { }
-    }
-    public interface IAsyncIListProvider<TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
-    {
-        System.Threading.Tasks.ValueTask<int> GetCountAsync(bool onlyIfCheap, System.Threading.CancellationToken cancellationToken);
-        System.Threading.Tasks.ValueTask<TElement[]> ToArrayAsync(System.Threading.CancellationToken cancellationToken);
-        System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TElement>> ToListAsync(System.Threading.CancellationToken cancellationToken);
-    }
-}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs
index 067c12170..a186ec767 100644
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs
@@ -1,7 +1,7 @@
 [assembly: System.CLSCompliant(true)]
 [assembly: System.Resources.NeutralResourcesLanguage("en-US")]
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
 namespace System.Linq
 {
     public static class AsyncEnumerableEx
@@ -9,6 +9,17 @@ public static class AsyncEnumerableEx
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Amb<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
+        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
         public static System.Collections.Generic.IAsyncEnumerable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count, int skip) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Catch<TSource>(params System.Collections.Generic.IAsyncEnumerable<TSource>[] sources) { }
@@ -98,6 +109,9 @@ public static System.Collections.Generic.IAsyncEnumerable<TOther> SelectMany<TSo
         public static System.Collections.Generic.IAsyncEnumerable<TSource> StartWith<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, params TSource[] values) { }
         public static System.Collections.Generic.IAsyncEnumerable<TValue> Throw<TValue>(System.Exception exception) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Timeout<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.TimeSpan timeout) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.IObservable<TSource> source) { }
+        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.Threading.Tasks.Task<TSource> task) { }
+        public static System.IObservable<TSource> ToObservable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<System.Threading.Tasks.Task<TResource>> resourceFactory, System.Func<TResource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>> enumerableFactory)
             where TResource : System.IDisposable { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Using<TSource, TResource>(System.Func<TResource> resourceFactory, System.Func<TResource, System.Collections.Generic.IAsyncEnumerable<TSource>> enumerableFactory)
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs
deleted file mode 100644
index 55fa24db5..000000000
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.received.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-[assembly: System.CLSCompliant(true)]
-[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
-[assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
-namespace System.Linq
-{
-    [System.Linq.LocalQueryMethodImplementationType(typeof(System.Linq.AsyncEnumerableEx))]
-    public static class AsyncQueryableEx
-    {
-        public static System.Linq.IAsyncQueryable<TSource> Amb<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Linq.IAsyncQueryable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
-        public static System.Linq.IAsyncQueryable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count, int skip) { }
-        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource, TException>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.Collections.Generic.IAsyncEnumerable<TSource>>> handler) { }
-        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource, TException>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> handler) { }
-        public static System.Linq.IAsyncQueryable<TSource> Catch<TSource, TException>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> handler) { }
-        public static System.Linq.IAsyncQueryable<TSource> Concat<TSource>(this System.Linq.IAsyncQueryable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> DistinctUntilChanged<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.IObserver<TSource> observer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext, System.Action onCompleted) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext, System.Linq.Expressions.Expression<System.Action<System.Exception>> onError) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Threading.Tasks.Task>> onCompleted) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.Tasks.Task>> onError) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task>> onCompleted) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onError) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Action<TSource>> onNext, System.Linq.Expressions.Expression<System.Action<System.Exception>> onError, System.Action onCompleted) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.Tasks.Task>> onError, System.Linq.Expressions.Expression<System.Func<System.Threading.Tasks.Task>> onCompleted) { }
-        public static System.Linq.IAsyncQueryable<TSource> Do<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onNext, System.Linq.Expressions.Expression<System.Func<System.Exception, System.Threading.CancellationToken, System.Threading.Tasks.Task>> onError, System.Linq.Expressions.Expression<System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task>> onCompleted) { }
-        public static System.Linq.IAsyncQueryable<TSource> Expand<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TSource>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TSource> Expand<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TSource> Expand<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TSource>>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TSource> Finally<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Action finallyAction) { }
-        public static System.Linq.IAsyncQueryable<TSource> Finally<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<System.Threading.Tasks.Task>> finallyAction) { }
-        public static System.Linq.IAsyncQueryable<TSource> IgnoreElements<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Threading.Tasks.ValueTask<bool> IsEmptyAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MaxByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> Merge<TSource>(this System.Linq.IAsyncQueryable<System.Collections.Generic.IAsyncEnumerable<TSource>> sources) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.IList<TSource>> MinByAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> OnErrorResumeNext<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Linq.IAsyncQueryable<TSource> Repeat<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Linq.IAsyncQueryable<TSource> Repeat<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
-        public static System.Linq.IAsyncQueryable<TSource> Retry<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Linq.IAsyncQueryable<TSource> Retry<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int retryCount) { }
-        public static System.Linq.IAsyncQueryable<TSource> Scan<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>>> accumulator) { }
-        public static System.Linq.IAsyncQueryable<TSource> Scan<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, TSource>> accumulator) { }
-        public static System.Linq.IAsyncQueryable<TSource> Scan<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>>> accumulator) { }
-        public static System.Linq.IAsyncQueryable<TAccumulate> Scan<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator) { }
-        public static System.Linq.IAsyncQueryable<TAccumulate> Scan<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator) { }
-        public static System.Linq.IAsyncQueryable<TAccumulate> Scan<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator) { }
-        public static System.Linq.IAsyncQueryable<TOther> SelectMany<TSource, TOther>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IAsyncEnumerable<TOther> other) { }
-        public static System.Linq.IAsyncQueryable<TSource> StartWith<TSource>(this System.Linq.IAsyncQueryable<TSource> source, params TSource[] values) { }
-        public static System.Linq.IAsyncQueryable<TSource> Timeout<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.TimeSpan timeout) { }
-    }
-}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs
index a51d1bc7c..55fa24db5 100644
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs
@@ -1,7 +1,7 @@
 [assembly: System.CLSCompliant(true)]
 [assembly: System.Resources.NeutralResourcesLanguage("en-US")]
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
 namespace System.Linq
 {
     [System.Linq.LocalQueryMethodImplementationType(typeof(System.Linq.AsyncEnumerableEx))]
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs
deleted file mode 100644
index e19c26338..000000000
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.received.cs
+++ /dev/null
@@ -1,703 +0,0 @@
-[assembly: System.CLSCompliant(true)]
-[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
-[assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName=".NET Standard 2.1")]
-namespace System.Collections.Generic
-{
-    public static class AsyncEnumerator
-    {
-        public static System.Collections.Generic.IAsyncEnumerator<T> Create<T>(System.Func<System.Threading.Tasks.ValueTask<bool>> moveNextAsync, System.Func<T> getCurrent, System.Func<System.Threading.Tasks.ValueTask> disposeAsync) { }
-        public static System.Threading.Tasks.ValueTask<bool> MoveNextAsync<T>(this System.Collections.Generic.IAsyncEnumerator<T> source, System.Threading.CancellationToken cancellationToken) { }
-        public static System.Collections.Generic.IAsyncEnumerator<T> WithCancellation<T>(this System.Collections.Generic.IAsyncEnumerator<T> source, System.Threading.CancellationToken cancellationToken) { }
-    }
-}
-namespace System.Linq
-{
-    public static class AsyncEnumerable
-    {
-        public static System.Threading.Tasks.ValueTask<TSource> AggregateAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, TSource> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Func<TAccumulate, TResult> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the AggregateAwaitAsync now exists as overloads of AggregateAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the AggregateAwaitAsync functionality now exists as overloads of AggregateAs" +
-            "ync.")]
-        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the AggregateAwaitAsync functionality now exists as overloads of AggregateAs" +
-            "ync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Func<TAccumulate, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
-            "s of AggregateAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
-            "s of AggregateAsync.")]
-        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
-            "s of AggregateAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Func<TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AllAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
-            "e AllAwaitAsync functionality now exists as overloads of All.")]
-        public static System.Threading.Tasks.ValueTask<bool> AllAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
-            "e AllAwaitWithCancellationAsync functionality now exists as overloads of AllAsyn" +
-            "c.")]
-        public static System.Threading.Tasks.ValueTask<bool> AllAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
-            "e AnyAwaitAsync functionality now exists as overloads of AnyAsync.")]
-        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
-            "e AnyAwaitWithCancellationAsync functionality now exists as overloads of AnyAsyn" +
-            "c.")]
-        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Append<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource element) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Cast<TResult>(this System.Collections.Generic.IAsyncEnumerable<object> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource value, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the CountAwaitAsync functionality now exists as overloads of CountAsync.")]
-        public static System.Threading.Tasks.ValueTask<int> CountAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the CountAwaitWithCancellationAsync functionality now exists as overloads of Cou" +
-            "ntAsync.")]
-        public static System.Threading.Tasks.ValueTask<int> CountAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<T> Create<T>(System.Func<System.Threading.CancellationToken, System.Collections.Generic.IAsyncEnumerator<T>> getAsyncEnumerator) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource defaultValue) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Distinct<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource> ElementAtAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> ElementAtOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TValue> Empty<TValue>() { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the FirstAwaitAsync functionality now exists as overloads of FirstAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the FirstAwaitWithCancellationAsync functionality now exists as overloads of Fir" +
-            "stAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumera" +
-            "ble, and the FirstOrDefaultAwaitAsync functionality now exists as overloads of F" +
-            "irstOrDefaultAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumera" +
-            "ble, and the FirstOrDefaultAwaitWithCancellationAsync functionality now exists a" +
-            "s overloads of FirstOrDefaultAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use the language support for async foreach instead.")]
-        public static System.Threading.Tasks.Task ForEachAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> action, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use the language support for async foreach instead.")]
-        public static System.Threading.Tasks.Task ForEachAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource, int> action, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use the language support for async foreach instead.")]
-        public static System.Threading.Tasks.Task ForEachAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use the language support for async foreach instead.")]
-        public static System.Threading.Tasks.Task ForEachAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use the language support for async foreach instead.")]
-        public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken) { }
-        [System.Obsolete("Use the language support for async foreach instead.")]
-        public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken) { }
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwait functionality now exists as overloads of GroupBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
-            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
-            "pBy.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he GroupJoinAwaitWithCancellation functionality now exists as overloads of Group" +
-            "Join.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he GroupJoinAwaitWithCancellation functionality now exists as overloads of Group" +
-            "Join.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
-            "inAwait functionality now exists as overloads of Join.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
-            "inAwait functionality now exists as overloads of Join.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
-            "inAwaitWithCancellation functionality now exists as overloads of Join.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
-            "inAwaitWithCancellation functionality now exists as overloads of Join.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he LastAwaitAsync functionality now exists as overloads of LastAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he LastAwaitWithCancellationAsync functionality now exists as overloads of LastA" +
-            "sync.")]
-        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerab" +
-            "le, and the LastOrDefaultAwaitAsync functionality now exists as overloads of Las" +
-            "tOrDefaultAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerab" +
-            "le, and the LastOrDefaultAwaitWithCancellationAsync functionality now exists as " +
-            "overloads of LastOrDefaultAsync.")]
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the LongCountAwaitAsync functionality now exists as overloads of LongCountAs" +
-            "ync.")]
-        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
-            "and the LongCountAwaitWithCancellationAsync functionality now exists as overload" +
-            "s of LongCountAsync.")]
-        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by the MaxAsync overload that took a selec" +
-            "tor callback now exists as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> MaxAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
-            " of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
-            "s as an overload of MaxByAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MinAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MinAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MinAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MinAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MinAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MinAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by the MinAsync overload that took a selec" +
-            "tor callback now exists as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> MinAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
-            " of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<double?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<float?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<int?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<long?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
-            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
-            "s as an overload of MinByAsync.")]
-        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> OfType<TResult>(this System.Collections.Generic.IAsyncEnumerable<object?> source) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Prepend<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource element) { }
-        public static System.Collections.Generic.IAsyncEnumerable<int> Range(int start, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Repeat<TResult>(TResult element, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Reverse<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, TResult> selector) { }
-        [System.Obsolete("Use Aggregate. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
-            "he AggregateAwait and AggregateAwaitWithCancellationAsync functionality now exis" +
-            "ts as overloads of Aggregate.")]
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
-        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Skip<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAsync(this System.Collections.Generic.IAsyncEnumerable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAsync(this System.Collections.Generic.IAsyncEnumerable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAsync(this System.Collections.Generic.IAsyncEnumerable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Take<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource[]> ToArrayAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.IObservable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.Threading.Tasks.Task<TSource> task) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Collections.Generic.IEnumerable<TSource> ToEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TSource>> ToListAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.IObservable<TSource> ToObservable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
-        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
-                "First",
-                "Second"})]
-        public static System.Collections.Generic.IAsyncEnumerable<System.ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, TResult> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> ZipAwait<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, System.Threading.Tasks.ValueTask<TResult>> selector) { }
-        public static System.Collections.Generic.IAsyncEnumerable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
-    }
-    public interface IAsyncGrouping<out TKey, out TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
-    {
-        TKey Key { get; }
-    }
-    [System.Obsolete("Use the definition of this type in the System.Interactive.Async NuGet package Sys" +
-        "tem.Linq.Async instead.")]
-    public interface IAsyncIListProvider<TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
-    {
-        System.Threading.Tasks.ValueTask<int> GetCountAsync(bool onlyIfCheap, System.Threading.CancellationToken cancellationToken);
-        System.Threading.Tasks.ValueTask<TElement[]> ToArrayAsync(System.Threading.CancellationToken cancellationToken);
-        System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TElement>> ToListAsync(System.Threading.CancellationToken cancellationToken);
-    }
-    public interface IOrderedAsyncEnumerable<out TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
-    {
-        System.Linq.IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, bool descending);
-        System.Linq.IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, bool descending);
-        System.Linq.IOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer, bool descending);
-    }
-}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs
index 2734bde4b..c81fb1a09 100644
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs
@@ -1,7 +1,7 @@
 [assembly: System.CLSCompliant(true)]
 [assembly: System.Resources.NeutralResourcesLanguage("en-US")]
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName=".NET Standard 2.1")]
 namespace System.Collections.Generic
 {
     public static class AsyncEnumerator
@@ -18,18 +18,45 @@ public static class AsyncEnumerable
         public static System.Threading.Tasks.ValueTask<TSource> AggregateAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, TSource> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Func<TAccumulate, TResult> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitAsync now exists as overloads of AggregateAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitAsync functionality now exists as overloads of AggregateAs" +
+            "ync.")]
         public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitAsync functionality now exists as overloads of AggregateAs" +
+            "ync.")]
         public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Func<TAccumulate, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of AggregateAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of AggregateAsync.")]
         public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AggregateAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the AggregateAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of AggregateAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>> accumulator, System.Func<TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<bool> AllAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AllAwaitAsync functionality now exists as overloads of All.")]
         public static System.Threading.Tasks.ValueTask<bool> AllAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AllAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AllAwaitWithCancellationAsync functionality now exists as overloads of AllAsyn" +
+            "c.")]
         public static System.Threading.Tasks.ValueTask<bool> AllAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AnyAwaitAsync functionality now exists as overloads of AnyAsync.")]
         public static System.Threading.Tasks.ValueTask<bool> AnyAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use AnyAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and th" +
+            "e AnyAwaitWithCancellationAsync functionality now exists as overloads of AnyAsyn" +
+            "c.")]
         public static System.Threading.Tasks.ValueTask<bool> AnyAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Append<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource element) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> AsAsyncEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
@@ -53,25 +80,45 @@ public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this
         public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then AverageAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its AverageAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use AverageAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> Cast<TResult>(this System.Collections.Generic.IAsyncEnumerable<object> source) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
@@ -79,7 +126,12 @@ public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this
         public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the CountAwaitAsync functionality now exists as overloads of CountAsync.")]
         public static System.Threading.Tasks.ValueTask<int> CountAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use CountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the CountAwaitWithCancellationAsync functionality now exists as overloads of Cou" +
+            "ntAsync.")]
         public static System.Threading.Tasks.ValueTask<int> CountAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<T> Create<T>(System.Func<System.Threading.CancellationToken, System.Collections.Generic.IAsyncEnumerator<T>> getAsyncEnumerator) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
@@ -93,17 +145,34 @@ public static System.Collections.Generic.IAsyncEnumerable<TSource> Except<TSourc
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
         public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the FirstAwaitAsync functionality now exists as overloads of FirstAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the FirstAwaitWithCancellationAsync functionality now exists as overloads of Fir" +
+            "stAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumera" +
+            "ble, and the FirstOrDefaultAwaitAsync functionality now exists as overloads of F" +
+            "irstOrDefaultAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use FirstOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumera" +
+            "ble, and the FirstOrDefaultAwaitWithCancellationAsync functionality now exists a" +
+            "s overloads of FirstOrDefaultAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
         public static System.Threading.Tasks.Task ForEachAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
         public static System.Threading.Tasks.Task ForEachAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Action<TSource, int> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
         public static System.Threading.Tasks.Task ForEachAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
         public static System.Threading.Tasks.Task ForEachAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
         public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken) { }
+        [System.Obsolete("Use the language support for async foreach instead.")]
         public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.Task> action, System.Threading.CancellationToken cancellationToken) { }
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
@@ -113,47 +182,122 @@ public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSour
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult> resultSelector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwait functionality now exists as overloads of GroupBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " GroupByAwaitWithCancellationAsync functionality now exists as overloads of Grou" +
+            "pBy.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult> resultSelector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwait functionality now exists as overloads of GroupJoin.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwaitWithCancellation functionality now exists as overloads of Group" +
+            "Join.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use GroupJoin. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he GroupJoinAwaitWithCancellation functionality now exists as overloads of Group" +
+            "Join.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwait functionality now exists as overloads of Join.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwait functionality now exists as overloads of Join.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwaitWithCancellation functionality now exists as overloads of Join.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use Join. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Jo" +
+            "inAwaitWithCancellation functionality now exists as overloads of Join.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IAsyncEnumerable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> outerKeySelector, System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> innerKeySelector, System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
         public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he LastAwaitAsync functionality now exists as overloads of LastAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> LastAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he LastAwaitWithCancellationAsync functionality now exists as overloads of LastA" +
+            "sync.")]
         public static System.Threading.Tasks.ValueTask<TSource> LastAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerab" +
+            "le, and the LastOrDefaultAwaitAsync functionality now exists as overloads of Las" +
+            "tOrDefaultAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LastOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerab" +
+            "le, and the LastOrDefaultAwaitWithCancellationAsync functionality now exists as " +
+            "overloads of LastOrDefaultAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the LongCountAwaitAsync functionality now exists as overloads of LongCountAs" +
+            "ync.")]
         public static System.Threading.Tasks.ValueTask<long> LongCountAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use LongCountAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, " +
+            "and the LongCountAwaitWithCancellationAsync functionality now exists as overload" +
+            "s of LongCountAsync.")]
         public static System.Threading.Tasks.ValueTask<long> LongCountAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<decimal> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<double> MaxAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
@@ -176,28 +320,97 @@ public static System.Threading.Tasks.ValueTask<float> MaxAsync<TSource>(this Sys
         public static System.Threading.Tasks.ValueTask<float?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<int?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<long?> MaxAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by the MaxAsync overload that took a selec" +
+            "tor callback now exists as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> MaxAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<double> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<int> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<long> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<float> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<double?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<float?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<int?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<long?> MaxAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitAsync now exists as an overload" +
+            " of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<double> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<int> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<long> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<float> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<double?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<float?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<int?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<long?> MaxAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MaxByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MaxAwaitWithCancellationAsync now exist" +
+            "s as an overload of MaxByAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<decimal> MinAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<double> MinAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
@@ -220,41 +433,130 @@ public static System.Threading.Tasks.ValueTask<float> MinAsync<TSource>(this Sys
         public static System.Threading.Tasks.ValueTask<float?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<int?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<long?> MinAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by the MinAsync overload that took a selec" +
+            "tor callback now exists as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> MinAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<double> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<int> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<long> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<float> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<double?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<float?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<int?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<long?> MinAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitAsync now exists as an overload" +
+            " of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> MinAwaitAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<double> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<int> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<long> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<float> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<double?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<float?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<int?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<long?> MinAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use MinByAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the functionality previously provided by MinAwaitWithCancellationAsync now exist" +
+            "s as an overload of MinByAsync.")]
         public static System.Threading.Tasks.ValueTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> OfType<TResult>(this System.Collections.Generic.IAsyncEnumerable<object?> source) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " OrderByAwait functionality now exists as overloads of OrderBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " OrderByAwait functionality now exists as overloads of OrderBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " OrderByAwaitWithCancellation functionality now exists as overloads of OrderBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use OrderBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the" +
+            " OrderByAwaitWithCancellation functionality now exists as overloads of OrderBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the OrderByDescendingAwait functionality now exists as overloads of Order" +
+            "ByDescending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the OrderByDescendingAwait functionality now exists as overloads of Order" +
+            "ByDescending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the OrderByDescendingAwaitWithCancellation functionality now exists as ov" +
+            "erloads of OrderByDescending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use OrderByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the OrderByDescendingAwaitWithCancellation functionality now exists as ov" +
+            "erloads of OrderByDescending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Prepend<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, TSource element) { }
         public static System.Collections.Generic.IAsyncEnumerable<int> Range(int start, int count) { }
@@ -262,39 +564,88 @@ public static System.Collections.Generic.IAsyncEnumerable<TResult> Repeat<TResul
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Reverse<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TResult> selector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, TResult> selector) { }
+        [System.Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "SelectAwait functionality now exists as overloads of Select.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        [System.Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "SelectAwait functionality now exists as overloads of Select.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        [System.Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "SelectAwaitWithCancellation functionality now exists as overloads of Select.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        [System.Obsolete("Use Select. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "SelectAwaitWithCancellation functionality now exists as overloads of Select.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TResult>> selector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TResult>> selector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwait functionality now exists as overloads of SelectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwaitWithCancellation functionality now exists as overloads of Sel" +
+            "ectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwaitWithCancellation functionality now exists as overloads of Sel" +
+            "ectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwaitWithCancellation functionality now exists as overloads of Sel" +
+            "ectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
+        [System.Obsolete("Use SelectMany. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and " +
+            "the SelectManyAwaitWithCancellation functionality now exists as overloads of Sel" +
+            "ectMany.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> resultSelector) { }
         public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use SingleAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and" +
+            " the SingleAwaitAsync functionality now exists as overloads of SingleAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use SingleAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and" +
+            " the SingleAwaitWithCancellationAsync functionality now exists as overloads of S" +
+            "ingleAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use SingleOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumer" +
+            "able, and the SingleOrDefaultAwaitAsync functionality now exists as overloads of" +
+            " SingleOrDefaultAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use SingleOrDefaultAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumer" +
+            "able, and the SingleOrDefaultAwaitWithCancellationAsync functionality now exists" +
+            " as overloads of SingleOrDefaultAsync.")]
         public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Skip<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
+        [System.Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he SkipWhileAwait functionality now exists as overloads of SkipWhile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he SkipWhileAwait functionality now exists as overloads of SkipWhile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he SkipWhileAwaitWithCancellation functionality now exists as overloads of SkipW" +
+            "hile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use SkipWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he SkipWhileAwaitWithCancellation functionality now exists as overloads of SkipW" +
+            "hile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
         public static System.Threading.Tasks.ValueTask<decimal> SumAsync(this System.Collections.Generic.IAsyncEnumerable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<double> SumAsync(this System.Collections.Generic.IAsyncEnumerable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
@@ -306,55 +657,115 @@ public static System.Threading.Tasks.ValueTask<float> SumAsync(this System.Colle
         public static System.Threading.Tasks.ValueTask<float?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<int?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<long?> SumAsync(this System.Collections.Generic.IAsyncEnumerable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<int> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<long> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, decimal?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, double?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, float?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<int?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<long?> SumAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, long?> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<int> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<long> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<int?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<long?> SumAwaitAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<int> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<long> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<double?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<float?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<int?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete(@"Use Select then SumAsync. System.Linq.Async (a community-supported library) has been replaced by the (Microsoft supported) IAsyncEnumerable LINQ in System.Linq.AsyncEnumerable, and its SumAsync method does not include the overloads that take a selector. So you should use Select to perform the projection and then use SumAsync on the resulting sequence.")]
         public static System.Threading.Tasks.ValueTask<long?> SumAwaitWithCancellationAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Take<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeLast<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, int count) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
+        [System.Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he TakeWhileAwait functionality now exists as overloads of TakeWhile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he TakeWhileAwait functionality now exists as overloads of TakeWhile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he TakeWhileAwaitWithCancellation functionality now exists as overloads of TakeW" +
+            "hile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use TakeWhile. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and t" +
+            "he TakeWhileAwaitWithCancellation functionality now exists as overloads of TakeW" +
+            "hile.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "ThenByAwait functionality now exists as overloads of ThenBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "ThenByAwait functionality now exists as overloads of ThenBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "ThenByAwaitWithCancellation functionality now exists as overloads of ThenBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use ThenBy. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the " +
+            "ThenByAwaitWithCancellation functionality now exists as overloads of ThenBy.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { }
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable" +
+            ", and the ThenByDescendingAwait functionality now exists as overloads of ThenByD" +
+            "escending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable" +
+            ", and the ThenByDescendingAwait functionality now exists as overloads of ThenByD" +
+            "escending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
+        [System.Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable" +
+            ", and the ThenByDescendingAwaitWithCancellation functionality now exists as over" +
+            "loads of ThenByDescending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector) { }
+        [System.Obsolete("Use ThenByDescending. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable" +
+            ", and the ThenByDescendingAwaitWithCancellation functionality now exists as over" +
+            "loads of ThenByDescending.")]
         public static System.Linq.IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
         public static System.Threading.Tasks.ValueTask<TSource[]> ToArrayAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { }
@@ -368,22 +779,49 @@ public static System.Collections.Generic.IAsyncEnumerable<TSource> ToAsyncEnumer
             where TKey :  notnull { }
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDic" +
+            "tionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDic" +
+            "tionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDic" +
+            "tionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitAsync functionality now exists as overloads of ToDic" +
+            "tionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as ov" +
+            "erloads of ToDictionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as ov" +
+            "erloads of ToDictionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as ov" +
+            "erloads of ToDictionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("Use ToDictionaryAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerabl" +
+            "e, and the ToDictionaryAwaitWithCancellationAsync functionality now exists as ov" +
+            "erloads of ToDictionaryAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
             where TKey :  notnull { }
+        [System.Obsolete("IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and it does not impl" +
+            "ement this method because \'sync over async\' of this kind is an anti-pattern. Ple" +
+            "ase use a different strategy.")]
         public static System.Collections.Generic.IEnumerable<TSource> ToEnumerable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
@@ -392,35 +830,74 @@ public static System.Collections.Generic.IEnumerable<TSource> ToEnumerable<TSour
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync" +
+            ".")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync" +
+            ".")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync" +
+            ".")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitAsync functionality now exists as overloads of ToLookupAsync" +
+            ".")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitWithCancellationAsync functionality now exists as overloads " +
+            "of ToLookupAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitWithCancellationAsync functionality now exists as overloads " +
+            "of ToLookupAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitWithCancellationAsync functionality now exists as overloads " +
+            "of ToLookupAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
+        [System.Obsolete("Use ToLookupAsync. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, a" +
+            "nd the ToLookupAwaitWithCancellationAsync functionality now exists as overloads " +
+            "of ToLookupAsync.")]
         public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>> keySelector, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
         public static System.IObservable<TSource> ToObservable<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, bool> predicate) { }
         public static System.Collections.Generic.IAsyncEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { }
+        [System.Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the W" +
+            "hereAwait functionality now exists as overloads of Where.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the W" +
+            "hereAwait functionality now exists as overloads of Where.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwait<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the W" +
+            "hereAwaitWithCancellation functionality now exists as overloads of Where.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
+        [System.Obsolete("Use Where. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the W" +
+            "hereAwaitWithCancellation functionality now exists as overloads of Where.")]
         public static System.Collections.Generic.IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this System.Collections.Generic.IAsyncEnumerable<TSource> source, System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>> predicate) { }
         [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
                 "First",
                 "Second"})]
         public static System.Collections.Generic.IAsyncEnumerable<System.ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second) { }
         public static System.Collections.Generic.IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, TResult> selector) { }
+        [System.Obsolete("Use Zip. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Zip" +
+            "Await functionality now exists as overloads of Zip.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> ZipAwait<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, System.Threading.Tasks.ValueTask<TResult>> selector) { }
+        [System.Obsolete("Use Zip. IAsyncEnumerable LINQ is now in System.Linq.AsyncEnumerable, and the Zip" +
+            "AwaitWithCancellation functionality now exists as overloads of Zip.")]
         public static System.Collections.Generic.IAsyncEnumerable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this System.Collections.Generic.IAsyncEnumerable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Func<TFirst, TSecond, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>> selector) { }
     }
     public interface IAsyncGrouping<out TKey, out TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
     {
         TKey Key { get; }
     }
+    [System.Obsolete("This interface was always unsupported, and the IAsyncEnumerable<T> LINQ implement" +
+        "ation in System.Linq.AsyncEnumerable does not recognize it, so this no longer se" +
+        "rves a purpose")]
     public interface IAsyncIListProvider<TElement> : System.Collections.Generic.IAsyncEnumerable<TElement>
     {
         System.Threading.Tasks.ValueTask<int> GetCountAsync(bool onlyIfCheap, System.Threading.CancellationToken cancellationToken);
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs
deleted file mode 100644
index 33196b616..000000000
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.received.cs
+++ /dev/null
@@ -1,413 +0,0 @@
-[assembly: System.CLSCompliant(true)]
-[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
-[assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName=".NET Standard 2.1")]
-namespace System.Linq
-{
-    public static class AsyncQueryable
-    {
-        public static System.Threading.Tasks.ValueTask<TSource> AggregateAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, TSource>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, TResult>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.Tasks.ValueTask<TSource>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TSource>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this System.Linq.IAsyncQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TAccumulate>>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AllAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AllAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AllAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AnyAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> AnyAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> Append<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource element) { }
-        public static System.Linq.IAsyncQueryable<TElement> AsAsyncQueryable<TElement>(this System.Collections.Generic.IAsyncEnumerable<TElement> source) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TResult> Cast<TResult>(this System.Linq.IAsyncQueryable<object> source) { }
-        public static System.Linq.IAsyncQueryable<TSource> Concat<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource value, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> ContainsAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> CountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> CountAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> CountAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Linq.IAsyncQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource defaultValue) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Linq.IAsyncQueryable<TSource> Distinct<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource> ElementAtAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> ElementAtOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int index, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> Except<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Linq.IAsyncQueryable<TSource> Except<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<System.Linq.IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TSource>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IAsyncEnumerable<TElement>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IAsyncEnumerable<TInner>, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Intersect<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Linq.IAsyncQueryable<TSource> Intersect<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this System.Linq.IAsyncQueryable<TOuter> outer, System.Collections.Generic.IAsyncEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> LastAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> LastAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> LastOrDefaultAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> LongCountAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> LongCountAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MaxAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MaxAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MaxAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MaxAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MaxAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MaxAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MaxAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MaxAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MaxAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> MaxAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MaxAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MinAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MinAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MinAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MinAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MinAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MinAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MinAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MinAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MinAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MinAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> MinAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MinAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> MinAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TResult> OfType<TResult>(this System.Linq.IAsyncQueryable<object?> source) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwait<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Prepend<TSource>(this System.Linq.IAsyncQueryable<TSource> source, TSource element) { }
-        public static System.Linq.IAsyncQueryable<TSource> Reverse<TSource>(this System.Linq.IAsyncQueryable<TSource> source) { }
-        public static System.Linq.IAsyncQueryable<TResult> Select<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> Select<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, TResult>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IAsyncEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TResult>>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Linq.IAsyncQueryable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<System.Collections.Generic.IAsyncEnumerable<TCollection>>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> resultSelector) { }
-        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<bool> SequenceEqualAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<TSource?> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> Skip<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipLast<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> SkipWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAsync(this System.Linq.IAsyncQueryable<decimal> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAsync(this System.Linq.IAsyncQueryable<double> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAsync(this System.Linq.IAsyncQueryable<int> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAsync(this System.Linq.IAsyncQueryable<long> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAsync(this System.Linq.IAsyncQueryable<float> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync(this System.Linq.IAsyncQueryable<decimal?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAsync(this System.Linq.IAsyncQueryable<double?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAsync(this System.Linq.IAsyncQueryable<float?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAsync(this System.Linq.IAsyncQueryable<int?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAsync(this System.Linq.IAsyncQueryable<long?> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long?>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAwaitAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<decimal?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<double?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<double?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<float?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<float?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<int?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<int?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<long?> SumAwaitWithCancellationAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<long?>>> selector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> Take<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeLast<TSource>(this System.Linq.IAsyncQueryable<TSource> source, int count) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeWhile<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> TakeWhileAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwait<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector) { }
-        public static System.Linq.IOrderedAsyncQueryable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this System.Linq.IOrderedAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IComparer<TKey>? comparer) { }
-        public static System.Threading.Tasks.ValueTask<TSource[]> ToArrayAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default)
-            where TKey :  notnull { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.HashSet<TSource>> ToHashSetAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Collections.Generic.List<TSource>> ToListAsync<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Threading.Tasks.ValueTask<System.Linq.ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TKey>>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TElement>>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Threading.CancellationToken cancellationToken = default) { }
-        public static System.Linq.IAsyncQueryable<TSource> Union<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second) { }
-        public static System.Linq.IAsyncQueryable<TSource> Union<TSource>(this System.Linq.IAsyncQueryable<TSource> first, System.Collections.Generic.IAsyncEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { }
-        public static System.Linq.IAsyncQueryable<TSource> Where<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> Where<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> WhereAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> WhereAwait<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> WhereAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<TSource> WhereAwaitWithCancellation<TSource>(this System.Linq.IAsyncQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<bool>>> predicate) { }
-        public static System.Linq.IAsyncQueryable<System.ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second) { }
-        public static System.Linq.IAsyncQueryable<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, TResult>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> ZipAwait<TFirst, TSecond, TResult>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
-        public static System.Linq.IAsyncQueryable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this System.Linq.IAsyncQueryable<TFirst> first, System.Collections.Generic.IAsyncEnumerable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask<TResult>>> selector) { }
-    }
-    public interface IAsyncQueryProvider
-    {
-        System.Linq.IAsyncQueryable<TElement> CreateQuery<TElement>(System.Linq.Expressions.Expression expression);
-        System.Threading.Tasks.ValueTask<TResult> ExecuteAsync<TResult>(System.Linq.Expressions.Expression expression, System.Threading.CancellationToken token);
-    }
-    public interface IAsyncQueryable
-    {
-        System.Type ElementType { get; }
-        System.Linq.Expressions.Expression Expression { get; }
-        System.Linq.IAsyncQueryProvider Provider { get; }
-    }
-    public interface IAsyncQueryable<out T> : System.Collections.Generic.IAsyncEnumerable<T>, System.Linq.IAsyncQueryable { }
-    public interface IOrderedAsyncQueryable : System.Linq.IAsyncQueryable { }
-    public interface IOrderedAsyncQueryable<out T> : System.Collections.Generic.IAsyncEnumerable<T>, System.Linq.IAsyncQueryable, System.Linq.IAsyncQueryable<T>, System.Linq.IOrderedAsyncQueryable { }
-    [System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
-    public sealed class LocalQueryMethodImplementationTypeAttribute : System.Attribute
-    {
-        public LocalQueryMethodImplementationTypeAttribute(System.Type targetType) { }
-        public System.Type TargetType { get; }
-    }
-}
\ No newline at end of file
diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs
index ef82c6d2c..33196b616 100644
--- a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs
+++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs
@@ -1,7 +1,7 @@
 [assembly: System.CLSCompliant(true)]
 [assembly: System.Resources.NeutralResourcesLanguage("en-US")]
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
-[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName=".NET Standard 2.1")]
 namespace System.Linq
 {
     public static class AsyncQueryable

From 840f3e689fba685f3f991ad06b9b4f836d46f8e5 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 16:19:27 +0100
Subject: [PATCH 09/10] Align ref and lib target frameworks

---
 .../System.Interactive.Providers.csproj                     | 6 ++----
 .../System.Interactive.Tests.csproj                         | 2 +-
 Ix.NET/Source/System.Interactive/System.Interactive.csproj  | 6 ++----
 .../System.Interactive.Providers.csproj                     | 2 +-
 .../refs/System.Interactive/System.Interactive.csproj       | 2 +-
 .../Source/refs/System.Linq.Async/System.Linq.Async.csproj  | 2 +-
 6 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj b/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj
index 09eba524d..6042eb1b5 100644
--- a/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj
+++ b/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Interactive Extensions Providers Library used to build query providers and express queries over enumerable sequences.</Description>
     <AssemblyTitle>Interactive Extensions - Providers Library</AssemblyTitle>
-    <TargetFrameworks>net48;netstandard2.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;net8.0</TargetFrameworks>
     <PackageTags>Ix;Interactive;Extensions;Enumerable</PackageTags>
   </PropertyGroup>
 
@@ -21,9 +21,7 @@
   See ../../Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md
   -->
   <ItemGroup>
-    <None Include="../refs/System.Interactive.Providers/bin/$(Configuration)/$(TargetFramework)/**"
-          PackagePath="ref/$(TargetFramework)"
-          Pack="true" />
+    <None Include="../refs/System.Interactive.Providers/bin/$(Configuration)/$(TargetFramework)/**" PackagePath="ref/$(TargetFramework)" Pack="true" />
   </ItemGroup>
 
   <!--
diff --git a/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj b/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj
index 634d28bdb..70cdd2809 100644
--- a/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj
+++ b/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;net10.0;net8.0</TargetFrameworks>
 
     <!--
       CA1822: Make member static. Not necessary for test code.
diff --git a/Ix.NET/Source/System.Interactive/System.Interactive.csproj b/Ix.NET/Source/System.Interactive/System.Interactive.csproj
index 974b42d95..e7262eaff 100644
--- a/Ix.NET/Source/System.Interactive/System.Interactive.csproj
+++ b/Ix.NET/Source/System.Interactive/System.Interactive.csproj
@@ -4,7 +4,7 @@
     <Description>Interactive Extensions Main Library used to express queries over enumerable sequences.</Description>
     <AssemblyTitle>Interactive Extensions - Main Library</AssemblyTitle>
     <Authors>Microsoft</Authors>
-    <TargetFrameworks>net48;netstandard2.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;net8.0</TargetFrameworks>
     <PackageTags>Ix;Interactive;Extensions;Enumerable</PackageTags>
   </PropertyGroup>
 
@@ -18,9 +18,7 @@
   See ../../Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md
   -->
   <ItemGroup>
-    <None Include="../refs/System.Interactive/bin/$(Configuration)/$(TargetFramework)/**"
-          PackagePath="ref/$(TargetFramework)"
-          Pack="true" />
+    <None Include="../refs/System.Interactive/bin/$(Configuration)/$(TargetFramework)/**" PackagePath="ref/$(TargetFramework)" Pack="true" />
   </ItemGroup>
 
   <!--
diff --git a/Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj b/Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj
index d31936f4b..cd3b5ec82 100644
--- a/Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj
+++ b/Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj
@@ -11,7 +11,7 @@
   
     See ../../Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md
     -->
-    <TargetFrameworks>net48;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.1;net8.0</TargetFrameworks>
     <PackageTags>Ix;Interactive;Extensions;Enumerable</PackageTags>
   </PropertyGroup>
 
diff --git a/Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj b/Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj
index 47d0858a4..64ae74938 100644
--- a/Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj
+++ b/Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj
@@ -12,7 +12,7 @@
   
     See ../../Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md
     -->
-    <TargetFrameworks>net48;netstandard2.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.1;net8.0</TargetFrameworks>
     <PackageTags>Ix;Interactive;Extensions;Enumerable</PackageTags>
   </PropertyGroup>
 
diff --git a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
index 24ad29b46..6c4f969fb 100644
--- a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
+++ b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj
@@ -6,7 +6,7 @@
     <Description>LINQ Standard Query Operators used to express queries over asynchronous enumerable sequences.</Description>
     <AssemblyTitle>System.Linq.Async</AssemblyTitle>
     <Authors>Microsoft</Authors>
-    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net10.0</TargetFrameworks>
+    <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net8.0</TargetFrameworks>
     <PackageTags>Enumerable;Asynchronous;LINQ</PackageTags>
     <AssemblyName>System.Linq.Async</AssemblyName>
   </PropertyGroup>

From 24680b546910a31c77680e83cb7f62fe71c244f0 Mon Sep 17 00:00:00 2001
From: Ian Griffiths <Ian.Griffiths@endjin.com>
Date: Tue, 30 Sep 2025 16:40:05 +0100
Subject: [PATCH 10/10] Update version to v7.0

---
 Ix.NET/Source/version.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Ix.NET/Source/version.json b/Ix.NET/Source/version.json
index 98c407497..9dd54b7ec 100644
--- a/Ix.NET/Source/version.json
+++ b/Ix.NET/Source/version.json
@@ -1,5 +1,5 @@
 {
-  "version": "6.1.0-preview.{height}",
+  "version": "7.0.0-preview.{height}",
   "publicReleaseRefSpec": [
     "^refs/heads/main$", // we release out of main
     "^refs/heads/rel/v\\d+\\.\\d+", // we also release branches starting with vN.N