diff --git a/Rx.NET/Source/src/System.Reactive/Linq/IQueryLanguage.cs b/Rx.NET/Source/src/System.Reactive/Linq/IQueryLanguage.cs
index 1c3f12305..0c02d8a5a 100644
--- a/Rx.NET/Source/src/System.Reactive/Linq/IQueryLanguage.cs
+++ b/Rx.NET/Source/src/System.Reactive/Linq/IQueryLanguage.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
+namespace System.Reactive.Linq;
+
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -11,750 +13,748 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace System.Reactive.Linq
+/// <summary>
+/// Internal interface describing the LINQ to Events query language.
+/// </summary>
+internal partial interface IQueryLanguage
 {
-    /// <summary>
-    /// Internal interface describing the LINQ to Events query language.
-    /// </summary>
-    internal partial interface IQueryLanguage
-    {
-        #region * Aggregates *
-
-        IObservable<TAccumulate> Aggregate<TSource, TAccumulate>(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator);
-        IObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector);
-        IObservable<TSource> Aggregate<TSource>(IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator);
-        IObservable<bool> All<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<bool> Any<TSource>(IObservable<TSource> source);
-        IObservable<bool> Any<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<double> Average(IObservable<double> source);
-        IObservable<float> Average(IObservable<float> source);
-        IObservable<decimal> Average(IObservable<decimal> source);
-        IObservable<double> Average(IObservable<int> source);
-        IObservable<double> Average(IObservable<long> source);
-        IObservable<double?> Average(IObservable<double?> source);
-        IObservable<float?> Average(IObservable<float?> source);
-        IObservable<decimal?> Average(IObservable<decimal?> source);
-        IObservable<double?> Average(IObservable<int?> source);
-        IObservable<double?> Average(IObservable<long?> source);
-        IObservable<double> Average<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
-        IObservable<float> Average<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
-        IObservable<decimal> Average<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
-        IObservable<double> Average<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
-        IObservable<double> Average<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
-        IObservable<double?> Average<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
-        IObservable<float?> Average<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
-        IObservable<decimal?> Average<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
-        IObservable<double?> Average<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
-        IObservable<double?> Average<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
-        IObservable<bool> Contains<TSource>(IObservable<TSource> source, TSource value);
-        IObservable<bool> Contains<TSource>(IObservable<TSource> source, TSource value, IEqualityComparer<TSource> comparer);
-        IObservable<int> Count<TSource>(IObservable<TSource> source);
-        IObservable<int> Count<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource> ElementAt<TSource>(IObservable<TSource> source, int index);
-        IObservable<TSource?> ElementAtOrDefault<TSource>(IObservable<TSource> source, int index);
-        IObservable<TSource> FirstAsync<TSource>(IObservable<TSource> source);
-        IObservable<TSource> FirstAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource?> FirstOrDefaultAsync<TSource>(IObservable<TSource> source);
-        IObservable<TSource?> FirstOrDefaultAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<bool> IsEmpty<TSource>(IObservable<TSource> source);
-        IObservable<TSource> LastAsync<TSource>(IObservable<TSource> source);
-        IObservable<TSource> LastAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource?> LastOrDefaultAsync<TSource>(IObservable<TSource> source);
-        IObservable<TSource?> LastOrDefaultAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<long> LongCount<TSource>(IObservable<TSource> source);
-        IObservable<long> LongCount<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource> Max<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Max<TSource>(IObservable<TSource> source, IComparer<TSource> comparer);
-        IObservable<double> Max(IObservable<double> source);
-        IObservable<float> Max(IObservable<float> source);
-        IObservable<decimal> Max(IObservable<decimal> source);
-        IObservable<int> Max(IObservable<int> source);
-        IObservable<long> Max(IObservable<long> source);
-        IObservable<double?> Max(IObservable<double?> source);
-        IObservable<float?> Max(IObservable<float?> source);
-        IObservable<decimal?> Max(IObservable<decimal?> source);
-        IObservable<int?> Max(IObservable<int?> source);
-        IObservable<long?> Max(IObservable<long?> source);
-        IObservable<TResult> Max<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
-        IObservable<TResult> Max<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult> comparer);
-        IObservable<double> Max<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
-        IObservable<float> Max<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
-        IObservable<decimal> Max<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
-        IObservable<int> Max<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
-        IObservable<long> Max<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
-        IObservable<double?> Max<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
-        IObservable<float?> Max<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
-        IObservable<decimal?> Max<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
-        IObservable<int?> Max<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
-        IObservable<long?> Max<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
-        IObservable<IList<TSource>> MaxBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
-        IObservable<IList<TSource>> MaxBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
-        IObservable<TSource> Min<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Min<TSource>(IObservable<TSource> source, IComparer<TSource> comparer);
-        IObservable<double> Min(IObservable<double> source);
-        IObservable<float> Min(IObservable<float> source);
-        IObservable<decimal> Min(IObservable<decimal> source);
-        IObservable<int> Min(IObservable<int> source);
-        IObservable<long> Min(IObservable<long> source);
-        IObservable<double?> Min(IObservable<double?> source);
-        IObservable<float?> Min(IObservable<float?> source);
-        IObservable<decimal?> Min(IObservable<decimal?> source);
-        IObservable<int?> Min(IObservable<int?> source);
-        IObservable<long?> Min(IObservable<long?> source);
-        IObservable<TResult> Min<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
-        IObservable<TResult> Min<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult> comparer);
-        IObservable<double> Min<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
-        IObservable<float> Min<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
-        IObservable<decimal> Min<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
-        IObservable<int> Min<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
-        IObservable<long> Min<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
-        IObservable<double?> Min<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
-        IObservable<float?> Min<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
-        IObservable<decimal?> Min<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
-        IObservable<int?> Min<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
-        IObservable<long?> Min<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
-        IObservable<IList<TSource>> MinBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
-        IObservable<IList<TSource>> MinBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
-        IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IObservable<TSource> second);
-        IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IObservable<TSource> second, IEqualityComparer<TSource> comparer);
-        IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IEnumerable<TSource> second);
-        IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
-        IObservable<TSource> SingleAsync<TSource>(IObservable<TSource> source);
-        IObservable<TSource> SingleAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource?> SingleOrDefaultAsync<TSource>(IObservable<TSource> source);
-        IObservable<TSource?> SingleOrDefaultAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<double> Sum(IObservable<double> source);
-        IObservable<float> Sum(IObservable<float> source);
-        IObservable<decimal> Sum(IObservable<decimal> source);
-        IObservable<int> Sum(IObservable<int> source);
-        IObservable<long> Sum(IObservable<long> source);
-        IObservable<double?> Sum(IObservable<double?> source);
-        IObservable<float?> Sum(IObservable<float?> source);
-        IObservable<decimal?> Sum(IObservable<decimal?> source);
-        IObservable<int?> Sum(IObservable<int?> source);
-        IObservable<long?> Sum(IObservable<long?> source);
-        IObservable<double> Sum<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
-        IObservable<float> Sum<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
-        IObservable<decimal> Sum<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
-        IObservable<int> Sum<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
-        IObservable<long> Sum<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
-        IObservable<double?> Sum<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
-        IObservable<float?> Sum<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
-        IObservable<decimal?> Sum<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
-        IObservable<int?> Sum<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
-        IObservable<long?> Sum<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
-        IObservable<TSource[]> ToArray<TSource>(IObservable<TSource> source);
-        IObservable<IDictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) where TKey : notnull;
-        IObservable<IDictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) where TKey : notnull;
-        IObservable<IDictionary<TKey, TSource>> ToDictionary<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) where TKey : notnull;
-        IObservable<IDictionary<TKey, TSource>> ToDictionary<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector) where TKey : notnull;
-        IObservable<IList<TSource>> ToList<TSource>(IObservable<TSource> source);
-        IObservable<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
-        IObservable<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
-        IObservable<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
-        IObservable<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
-
-        #endregion
-
-        #region * Async *
-
-        Func<IObservable<TResult>> FromAsyncPattern<TResult>(Func<AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, IObservable<TResult>> FromAsyncPattern<T1, TResult>(Func<T1, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, IObservable<TResult>> FromAsyncPattern<T1, T2, TResult>(Func<T1, T2, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, TResult>(Func<T1, T2, T3, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
-
-        Func<IObservable<Unit>> FromAsyncPattern(Func<AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, IObservable<Unit>> FromAsyncPattern<T1>(Func<T1, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, IObservable<Unit>> FromAsyncPattern<T1, T2>(Func<T1, T2, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, IObservable<Unit>> FromAsyncPattern<T1, T2, T3>(Func<T1, T2, T3, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4>(Func<T1, T2, T3, T4, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6>(Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7>(Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8>(Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
-
-        IObservable<TSource> Start<TSource>(Func<TSource> function);
-        IObservable<TSource> Start<TSource>(Func<TSource> function, IScheduler scheduler);
-
-        IObservable<TSource> StartAsync<TSource>(Func<Task<TSource>> functionAsync);
-        IObservable<TSource> StartAsync<TSource>(Func<CancellationToken, Task<TSource>> functionAsync);
-        IObservable<TSource> StartAsync<TSource>(Func<Task<TSource>> functionAsync, in TaskObservationOptions.Value options);
-        IObservable<TSource> StartAsync<TSource>(Func<CancellationToken, Task<TSource>> functionAsync, in TaskObservationOptions.Value options);
-
-        IObservable<Unit> Start(Action action);
-        IObservable<Unit> Start(Action action, IScheduler scheduler);
-
-        IObservable<Unit> StartAsync(Func<Task> actionAsync);
-        IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync);
-        IObservable<Unit> StartAsync(Func<Task> actionAsync, in TaskObservationOptions.Value options);
-        IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync, in TaskObservationOptions.Value options);
-
-        IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync);
-        IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync);
-        IObservable<Unit> FromAsync(Func<Task> actionAsync);
-        IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync);
-        IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync, TaskObservationOptions.Value options);
-        IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync, TaskObservationOptions.Value options);
-        IObservable<Unit> FromAsync(Func<Task> actionAsync, TaskObservationOptions.Value options);
-        IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync, TaskObservationOptions.Value options);
-
-        Func<IObservable<TResult>> ToAsync<TResult>(Func<TResult> function);
-        Func<IObservable<TResult>> ToAsync<TResult>(Func<TResult> function, IScheduler scheduler);
-        Func<T, IObservable<TResult>> ToAsync<T, TResult>(Func<T, TResult> function);
-        Func<T, IObservable<TResult>> ToAsync<T, TResult>(Func<T, TResult> function, IScheduler scheduler);
-        Func<T1, T2, IObservable<TResult>> ToAsync<T1, T2, TResult>(Func<T1, T2, TResult> function);
-        Func<T1, T2, IObservable<TResult>> ToAsync<T1, T2, TResult>(Func<T1, T2, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, IObservable<TResult>> ToAsync<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function);
-        Func<T1, T2, T3, IObservable<TResult>> ToAsync<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, IObservable<TResult>> ToAsync<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function);
-        Func<T1, T2, T3, T4, IObservable<TResult>> ToAsync<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function);
-        Func<T1, T2, T3, T4, T5, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> function, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> function);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> function, IScheduler scheduler);
-
-        Func<IObservable<Unit>> ToAsync(Action action);
-        Func<IObservable<Unit>> ToAsync(Action action, IScheduler scheduler);
-        Func<TSource, IObservable<Unit>> ToAsync<TSource>(Action<TSource> action);
-        Func<TSource, IObservable<Unit>> ToAsync<TSource>(Action<TSource> action, IScheduler scheduler);
-        Func<T1, T2, IObservable<Unit>> ToAsync<T1, T2>(Action<T1, T2> action);
-        Func<T1, T2, IObservable<Unit>> ToAsync<T1, T2>(Action<T1, T2> action, IScheduler scheduler);
-        Func<T1, T2, T3, IObservable<Unit>> ToAsync<T1, T2, T3>(Action<T1, T2, T3> action);
-        Func<T1, T2, T3, IObservable<Unit>> ToAsync<T1, T2, T3>(Action<T1, T2, T3> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, IObservable<Unit>> ToAsync<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action);
-        Func<T1, T2, T3, T4, IObservable<Unit>> ToAsync<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action);
-        Func<T1, T2, T3, T4, T5, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action);
-        Func<T1, T2, T3, T4, T5, T6, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> action, IScheduler scheduler);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> action);
-        Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> action, IScheduler scheduler);
-
-        #endregion
-
-        #region * Awaiter *
-
-        AsyncSubject<TSource> GetAwaiter<TSource>(IObservable<TSource> source);
-        AsyncSubject<TSource> GetAwaiter<TSource>(IConnectableObservable<TSource> source);
-        AsyncSubject<TSource> RunAsync<TSource>(IObservable<TSource> source, CancellationToken cancellationToken);
-        AsyncSubject<TSource> RunAsync<TSource>(IConnectableObservable<TSource> source, CancellationToken cancellationToken);
-
-        #endregion
-
-        #region * Binding *
-
-        IConnectableObservable<TResult> Multicast<TSource, TResult>(IObservable<TSource> source, ISubject<TSource, TResult> subject);
-        IObservable<TResult> Multicast<TSource, TIntermediate, TResult>(IObservable<TSource> source, Func<ISubject<TSource, TIntermediate>> subjectSelector, Func<IObservable<TIntermediate>, IObservable<TResult>> selector);
-        IConnectableObservable<TSource> Publish<TSource>(IObservable<TSource> source);
-        IObservable<TResult> Publish<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector);
-        IConnectableObservable<TSource> Publish<TSource>(IObservable<TSource> source, TSource initialValue);
-        IObservable<TResult> Publish<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TSource initialValue);
-        IConnectableObservable<TSource> PublishLast<TSource>(IObservable<TSource> source);
-        IObservable<TResult> PublishLast<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector);
-        IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source);
-        IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, TimeSpan disconnectDelay);
-        IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, TimeSpan disconnectDelay, IScheduler schedulder);
-        IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, int minObservers);
-        IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, int minObservers, TimeSpan disconnectDelay);
-        IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, int minObservers, TimeSpan disconnectDelay, IScheduler schedulder);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, IScheduler scheduler);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, IScheduler scheduler);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, TimeSpan window);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, TimeSpan window, IScheduler scheduler);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window, IScheduler scheduler);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize, IScheduler scheduler);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, IScheduler scheduler);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize, TimeSpan window);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window);
-        IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize, TimeSpan window, IScheduler scheduler);
-        IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window, IScheduler scheduler);
-        IObservable<TSource> AutoConnect<TSource>(IConnectableObservable<TSource> source, int minObservers, Action<IDisposable>? onConnect);
-
-        #endregion
-
-        #region * Blocking *
-
-        IEnumerable<IList<TSource>> Chunkify<TSource>(IObservable<TSource> source);
-        IEnumerable<TResult> Collect<TSource, TResult>(IObservable<TSource> source, Func<TResult> newCollector, Func<TResult, TSource, TResult> merge);
-        IEnumerable<TResult> Collect<TSource, TResult>(IObservable<TSource> source, Func<TResult> getInitialCollector, Func<TResult, TSource, TResult> merge, Func<TResult, TResult> getNewCollector);
-        TSource First<TSource>(IObservable<TSource> source);
-        TSource First<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        [return: MaybeNull] TSource FirstOrDefault<TSource>(IObservable<TSource> source);
-        [return: MaybeNull] TSource FirstOrDefault<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        void ForEach<TSource>(IObservable<TSource> source, Action<TSource> onNext);
-        void ForEach<TSource>(IObservable<TSource> source, Action<TSource, int> onNext);
-        IEnumerator<TSource> GetEnumerator<TSource>(IObservable<TSource> source);
-        TSource Last<TSource>(IObservable<TSource> source);
-        TSource Last<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        [return: MaybeNull] TSource LastOrDefault<TSource>(IObservable<TSource> source);
-        [return: MaybeNull] TSource LastOrDefault<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IEnumerable<TSource> Latest<TSource>(IObservable<TSource> source);
-        IEnumerable<TSource> MostRecent<TSource>(IObservable<TSource> source, TSource initialValue);
-        IEnumerable<TSource> Next<TSource>(IObservable<TSource> source);
-        TSource Single<TSource>(IObservable<TSource> source);
-        [return: MaybeNull] TSource SingleOrDefault<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        [return: MaybeNull] TSource SingleOrDefault<TSource>(IObservable<TSource> source);
-        TSource Single<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        TSource Wait<TSource>(IObservable<TSource> source);
-
-        #endregion
-
-        #region * Concurrency *
-
-        IObservable<TSource> ObserveOn<TSource>(IObservable<TSource> source, IScheduler scheduler);
-        IObservable<TSource> ObserveOn<TSource>(IObservable<TSource> source, SynchronizationContext context);
-
-        IObservable<TSource> SubscribeOn<TSource>(IObservable<TSource> source, IScheduler scheduler);
-        IObservable<TSource> SubscribeOn<TSource>(IObservable<TSource> source, SynchronizationContext context);
-
-        IObservable<TSource> Synchronize<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Synchronize<TSource>(IObservable<TSource> source, object gate);
-
-        #endregion
-
-        #region * Conversions *
-
-        IDisposable Subscribe<TSource>(IEnumerable<TSource> source, IObserver<TSource> observer);
-        IDisposable Subscribe<TSource>(IEnumerable<TSource> source, IObserver<TSource> observer, IScheduler scheduler);
-        IEnumerable<TSource> ToEnumerable<TSource>(IObservable<TSource> source);
-        IEventSource<Unit> ToEvent(IObservable<Unit> source);
-        IEventSource<TSource> ToEvent<TSource>(IObservable<TSource> source);
-        IEventPatternSource<TEventArgs> ToEventPattern<TEventArgs>(IObservable<EventPattern<TEventArgs>> source);
-        IObservable<TSource> ToObservable<TSource>(IEnumerable<TSource> source);
-        IObservable<TSource> ToObservable<TSource>(IEnumerable<TSource> source, IScheduler scheduler);
-
-        #endregion
-
-        #region * Creation *
-
-        IObservable<TSource> Create<TSource>(Func<IObserver<TSource>, IDisposable> subscribe);
-        IObservable<TSource> Create<TSource>(Func<IObserver<TSource>, Action> subscribe);
-        IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task> subscribeAsync);
-        IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task> subscribeAsync);
-        IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task<IDisposable>> subscribeAsync);
-        IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<IDisposable>> subscribeAsync);
-        IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task<Action>> subscribeAsync);
-        IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<Action>> subscribeAsync);
-
-        IObservable<TValue> Defer<TValue>(Func<IObservable<TValue>> observableFactory);
-
-        IObservable<TValue> Defer<TValue>(Func<Task<IObservable<TValue>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe);
-        IObservable<TValue> Defer<TValue>(Func<CancellationToken, Task<IObservable<TValue>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe);
-
-        IObservable<TResult> Empty<TResult>();
-        IObservable<TResult> Empty<TResult>(IScheduler scheduler);
-        IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector);
-        IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, IScheduler scheduler);
-        IObservable<TResult> Never<TResult>();
-        IObservable<int> Range(int start, int count);
-        IObservable<int> Range(int start, int count, IScheduler scheduler);
-        IObservable<TResult> Repeat<TResult>(TResult value);
-        IObservable<TResult> Repeat<TResult>(TResult value, IScheduler scheduler);
-        IObservable<TResult> Repeat<TResult>(TResult value, int repeatCount);
-        IObservable<TResult> Repeat<TResult>(TResult value, int repeatCount, IScheduler scheduler);
-        IObservable<TResult> Return<TResult>(TResult value);
-        IObservable<TResult> Return<TResult>(TResult value, IScheduler scheduler);
-        IObservable<TResult> Throw<TResult>(Exception exception);
-        IObservable<TResult> Throw<TResult>(Exception exception, IScheduler scheduler);
-        IObservable<TSource> Using<TSource, TResource>(Func<TResource> resourceFactory, Func<TResource, IObservable<TSource>> observableFactory) where TResource : IDisposable;
-        IObservable<TSource> Using<TSource, TResource>(Func<CancellationToken, Task<TResource>> resourceFactoryAsync, Func<TResource, CancellationToken, Task<IObservable<TSource>>> observableFactoryAsync) where TResource : IDisposable;
-
-        #endregion
-
-        #region * Events *
-
-        IObservable<EventPattern<object>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler);
-        IObservable<EventPattern<object>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler, IScheduler scheduler);
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler);
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler, IScheduler scheduler);
-        IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
-        IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
+    #region * Aggregates *
+
+    IObservable<TAccumulate> Aggregate<TSource, TAccumulate>(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator);
+    IObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector);
+    IObservable<TSource> Aggregate<TSource>(IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator);
+    IObservable<bool> All<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<bool> Any<TSource>(IObservable<TSource> source);
+    IObservable<bool> Any<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<double> Average(IObservable<double> source);
+    IObservable<float> Average(IObservable<float> source);
+    IObservable<decimal> Average(IObservable<decimal> source);
+    IObservable<double> Average(IObservable<int> source);
+    IObservable<double> Average(IObservable<long> source);
+    IObservable<double?> Average(IObservable<double?> source);
+    IObservable<float?> Average(IObservable<float?> source);
+    IObservable<decimal?> Average(IObservable<decimal?> source);
+    IObservable<double?> Average(IObservable<int?> source);
+    IObservable<double?> Average(IObservable<long?> source);
+    IObservable<double> Average<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
+    IObservable<float> Average<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
+    IObservable<decimal> Average<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
+    IObservable<double> Average<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
+    IObservable<double> Average<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
+    IObservable<double?> Average<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
+    IObservable<float?> Average<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
+    IObservable<decimal?> Average<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
+    IObservable<double?> Average<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
+    IObservable<double?> Average<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
+    IObservable<bool> Contains<TSource>(IObservable<TSource> source, TSource value);
+    IObservable<bool> Contains<TSource>(IObservable<TSource> source, TSource value, IEqualityComparer<TSource> comparer);
+    IObservable<int> Count<TSource>(IObservable<TSource> source);
+    IObservable<int> Count<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource> ElementAt<TSource>(IObservable<TSource> source, int index);
+    IObservable<TSource?> ElementAtOrDefault<TSource>(IObservable<TSource> source, int index);
+    IObservable<TSource> FirstAsync<TSource>(IObservable<TSource> source);
+    IObservable<TSource> FirstAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource?> FirstOrDefaultAsync<TSource>(IObservable<TSource> source);
+    IObservable<TSource?> FirstOrDefaultAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<bool> IsEmpty<TSource>(IObservable<TSource> source);
+    IObservable<TSource> LastAsync<TSource>(IObservable<TSource> source);
+    IObservable<TSource> LastAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource?> LastOrDefaultAsync<TSource>(IObservable<TSource> source);
+    IObservable<TSource?> LastOrDefaultAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<long> LongCount<TSource>(IObservable<TSource> source);
+    IObservable<long> LongCount<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource> Max<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Max<TSource>(IObservable<TSource> source, IComparer<TSource> comparer);
+    IObservable<double> Max(IObservable<double> source);
+    IObservable<float> Max(IObservable<float> source);
+    IObservable<decimal> Max(IObservable<decimal> source);
+    IObservable<int> Max(IObservable<int> source);
+    IObservable<long> Max(IObservable<long> source);
+    IObservable<double?> Max(IObservable<double?> source);
+    IObservable<float?> Max(IObservable<float?> source);
+    IObservable<decimal?> Max(IObservable<decimal?> source);
+    IObservable<int?> Max(IObservable<int?> source);
+    IObservable<long?> Max(IObservable<long?> source);
+    IObservable<TResult> Max<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
+    IObservable<TResult> Max<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult> comparer);
+    IObservable<double> Max<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
+    IObservable<float> Max<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
+    IObservable<decimal> Max<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
+    IObservable<int> Max<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
+    IObservable<long> Max<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
+    IObservable<double?> Max<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
+    IObservable<float?> Max<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
+    IObservable<decimal?> Max<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
+    IObservable<int?> Max<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
+    IObservable<long?> Max<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
+    IObservable<IList<TSource>> MaxBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
+    IObservable<IList<TSource>> MaxBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
+    IObservable<TSource> Min<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Min<TSource>(IObservable<TSource> source, IComparer<TSource> comparer);
+    IObservable<double> Min(IObservable<double> source);
+    IObservable<float> Min(IObservable<float> source);
+    IObservable<decimal> Min(IObservable<decimal> source);
+    IObservable<int> Min(IObservable<int> source);
+    IObservable<long> Min(IObservable<long> source);
+    IObservable<double?> Min(IObservable<double?> source);
+    IObservable<float?> Min(IObservable<float?> source);
+    IObservable<decimal?> Min(IObservable<decimal?> source);
+    IObservable<int?> Min(IObservable<int?> source);
+    IObservable<long?> Min(IObservable<long?> source);
+    IObservable<TResult> Min<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
+    IObservable<TResult> Min<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult> comparer);
+    IObservable<double> Min<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
+    IObservable<float> Min<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
+    IObservable<decimal> Min<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
+    IObservable<int> Min<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
+    IObservable<long> Min<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
+    IObservable<double?> Min<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
+    IObservable<float?> Min<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
+    IObservable<decimal?> Min<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
+    IObservable<int?> Min<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
+    IObservable<long?> Min<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
+    IObservable<IList<TSource>> MinBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
+    IObservable<IList<TSource>> MinBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
+    IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IObservable<TSource> second);
+    IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IObservable<TSource> second, IEqualityComparer<TSource> comparer);
+    IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IEnumerable<TSource> second);
+    IObservable<bool> SequenceEqual<TSource>(IObservable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
+    IObservable<TSource> SingleAsync<TSource>(IObservable<TSource> source);
+    IObservable<TSource> SingleAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource?> SingleOrDefaultAsync<TSource>(IObservable<TSource> source);
+    IObservable<TSource?> SingleOrDefaultAsync<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<double> Sum(IObservable<double> source);
+    IObservable<float> Sum(IObservable<float> source);
+    IObservable<decimal> Sum(IObservable<decimal> source);
+    IObservable<int> Sum(IObservable<int> source);
+    IObservable<long> Sum(IObservable<long> source);
+    IObservable<double?> Sum(IObservable<double?> source);
+    IObservable<float?> Sum(IObservable<float?> source);
+    IObservable<decimal?> Sum(IObservable<decimal?> source);
+    IObservable<int?> Sum(IObservable<int?> source);
+    IObservable<long?> Sum(IObservable<long?> source);
+    IObservable<double> Sum<TSource>(IObservable<TSource> source, Func<TSource, double> selector);
+    IObservable<float> Sum<TSource>(IObservable<TSource> source, Func<TSource, float> selector);
+    IObservable<decimal> Sum<TSource>(IObservable<TSource> source, Func<TSource, decimal> selector);
+    IObservable<int> Sum<TSource>(IObservable<TSource> source, Func<TSource, int> selector);
+    IObservable<long> Sum<TSource>(IObservable<TSource> source, Func<TSource, long> selector);
+    IObservable<double?> Sum<TSource>(IObservable<TSource> source, Func<TSource, double?> selector);
+    IObservable<float?> Sum<TSource>(IObservable<TSource> source, Func<TSource, float?> selector);
+    IObservable<decimal?> Sum<TSource>(IObservable<TSource> source, Func<TSource, decimal?> selector);
+    IObservable<int?> Sum<TSource>(IObservable<TSource> source, Func<TSource, int?> selector);
+    IObservable<long?> Sum<TSource>(IObservable<TSource> source, Func<TSource, long?> selector);
+    IObservable<TSource[]> ToArray<TSource>(IObservable<TSource> source);
+    IObservable<IDictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) where TKey : notnull;
+    IObservable<IDictionary<TKey, TElement>> ToDictionary<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) where TKey : notnull;
+    IObservable<IDictionary<TKey, TSource>> ToDictionary<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) where TKey : notnull;
+    IObservable<IDictionary<TKey, TSource>> ToDictionary<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector) where TKey : notnull;
+    IObservable<IList<TSource>> ToList<TSource>(IObservable<TSource> source);
+    IObservable<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
+    IObservable<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
+    IObservable<ILookup<TKey, TElement>> ToLookup<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
+    IObservable<ILookup<TKey, TSource>> ToLookup<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
+
+    #endregion
+
+    #region * Async *
+
+    Func<IObservable<TResult>> FromAsyncPattern<TResult>(Func<AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, IObservable<TResult>> FromAsyncPattern<T1, TResult>(Func<T1, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, IObservable<TResult>> FromAsyncPattern<T1, T2, TResult>(Func<T1, T2, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, TResult>(Func<T1, T2, T3, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<TResult>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object?, IAsyncResult> begin, Func<IAsyncResult, TResult> end);
+
+    Func<IObservable<Unit>> FromAsyncPattern(Func<AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, IObservable<Unit>> FromAsyncPattern<T1>(Func<T1, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, IObservable<Unit>> FromAsyncPattern<T1, T2>(Func<T1, T2, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, IObservable<Unit>> FromAsyncPattern<T1, T2, T3>(Func<T1, T2, T3, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4>(Func<T1, T2, T3, T4, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6>(Func<T1, T2, T3, T4, T5, T6, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7>(Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8>(Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<Unit>> FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, AsyncCallback, object?, IAsyncResult> begin, Action<IAsyncResult> end);
+
+    IObservable<TSource> Start<TSource>(Func<TSource> function);
+    IObservable<TSource> Start<TSource>(Func<TSource> function, IScheduler scheduler);
+
+    IObservable<TSource> StartAsync<TSource>(Func<Task<TSource>> functionAsync);
+    IObservable<TSource> StartAsync<TSource>(Func<CancellationToken, Task<TSource>> functionAsync);
+    IObservable<TSource> StartAsync<TSource>(Func<Task<TSource>> functionAsync, in TaskObservationOptions.Value options);
+    IObservable<TSource> StartAsync<TSource>(Func<CancellationToken, Task<TSource>> functionAsync, in TaskObservationOptions.Value options);
+
+    IObservable<Unit> Start(Action action);
+    IObservable<Unit> Start(Action action, IScheduler scheduler);
+
+    IObservable<Unit> StartAsync(Func<Task> actionAsync);
+    IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync);
+    IObservable<Unit> StartAsync(Func<Task> actionAsync, in TaskObservationOptions.Value options);
+    IObservable<Unit> StartAsync(Func<CancellationToken, Task> actionAsync, in TaskObservationOptions.Value options);
+
+    IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync);
+    IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync);
+    IObservable<Unit> FromAsync(Func<Task> actionAsync);
+    IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync);
+    IObservable<TResult> FromAsync<TResult>(Func<Task<TResult>> functionAsync, TaskObservationOptions.Value options);
+    IObservable<TResult> FromAsync<TResult>(Func<CancellationToken, Task<TResult>> functionAsync, TaskObservationOptions.Value options);
+    IObservable<Unit> FromAsync(Func<Task> actionAsync, TaskObservationOptions.Value options);
+    IObservable<Unit> FromAsync(Func<CancellationToken, Task> actionAsync, TaskObservationOptions.Value options);
+
+    Func<IObservable<TResult>> ToAsync<TResult>(Func<TResult> function);
+    Func<IObservable<TResult>> ToAsync<TResult>(Func<TResult> function, IScheduler scheduler);
+    Func<T, IObservable<TResult>> ToAsync<T, TResult>(Func<T, TResult> function);
+    Func<T, IObservable<TResult>> ToAsync<T, TResult>(Func<T, TResult> function, IScheduler scheduler);
+    Func<T1, T2, IObservable<TResult>> ToAsync<T1, T2, TResult>(Func<T1, T2, TResult> function);
+    Func<T1, T2, IObservable<TResult>> ToAsync<T1, T2, TResult>(Func<T1, T2, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, IObservable<TResult>> ToAsync<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function);
+    Func<T1, T2, T3, IObservable<TResult>> ToAsync<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, IObservable<TResult>> ToAsync<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function);
+    Func<T1, T2, T3, T4, IObservable<TResult>> ToAsync<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function);
+    Func<T1, T2, T3, T4, T5, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> function, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> function);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<TResult>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> function, IScheduler scheduler);
+
+    Func<IObservable<Unit>> ToAsync(Action action);
+    Func<IObservable<Unit>> ToAsync(Action action, IScheduler scheduler);
+    Func<TSource, IObservable<Unit>> ToAsync<TSource>(Action<TSource> action);
+    Func<TSource, IObservable<Unit>> ToAsync<TSource>(Action<TSource> action, IScheduler scheduler);
+    Func<T1, T2, IObservable<Unit>> ToAsync<T1, T2>(Action<T1, T2> action);
+    Func<T1, T2, IObservable<Unit>> ToAsync<T1, T2>(Action<T1, T2> action, IScheduler scheduler);
+    Func<T1, T2, T3, IObservable<Unit>> ToAsync<T1, T2, T3>(Action<T1, T2, T3> action);
+    Func<T1, T2, T3, IObservable<Unit>> ToAsync<T1, T2, T3>(Action<T1, T2, T3> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, IObservable<Unit>> ToAsync<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action);
+    Func<T1, T2, T3, T4, IObservable<Unit>> ToAsync<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action);
+    Func<T1, T2, T3, T4, T5, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action);
+    Func<T1, T2, T3, T4, T5, T6, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> action, IScheduler scheduler);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> action);
+    Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IObservable<Unit>> ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> action, IScheduler scheduler);
+
+    #endregion
+
+    #region * Awaiter *
+
+    AsyncSubject<TSource> GetAwaiter<TSource>(IObservable<TSource> source);
+    AsyncSubject<TSource> GetAwaiter<TSource>(IConnectableObservable<TSource> source);
+    AsyncSubject<TSource> RunAsync<TSource>(IObservable<TSource> source, CancellationToken cancellationToken);
+    AsyncSubject<TSource> RunAsync<TSource>(IConnectableObservable<TSource> source, CancellationToken cancellationToken);
+
+    #endregion
+
+    #region * Binding *
+
+    IConnectableObservable<TResult> Multicast<TSource, TResult>(IObservable<TSource> source, ISubject<TSource, TResult> subject);
+    IObservable<TResult> Multicast<TSource, TIntermediate, TResult>(IObservable<TSource> source, Func<ISubject<TSource, TIntermediate>> subjectSelector, Func<IObservable<TIntermediate>, IObservable<TResult>> selector);
+    IConnectableObservable<TSource> Publish<TSource>(IObservable<TSource> source);
+    IObservable<TResult> Publish<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector);
+    IConnectableObservable<TSource> Publish<TSource>(IObservable<TSource> source, TSource initialValue);
+    IObservable<TResult> Publish<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TSource initialValue);
+    IConnectableObservable<TSource> PublishLast<TSource>(IObservable<TSource> source);
+    IObservable<TResult> PublishLast<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector);
+    IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source);
+    IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, TimeSpan disconnectDelay);
+    IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, TimeSpan disconnectDelay, IScheduler schedulder);
+    IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, int minObservers);
+    IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, int minObservers, TimeSpan disconnectDelay);
+    IObservable<TSource> RefCount<TSource>(IConnectableObservable<TSource> source, int minObservers, TimeSpan disconnectDelay, IScheduler schedulder);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, IScheduler scheduler);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, IScheduler scheduler);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, TimeSpan window);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, TimeSpan window, IScheduler scheduler);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, TimeSpan window, IScheduler scheduler);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize, IScheduler scheduler);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, IScheduler scheduler);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize, TimeSpan window);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window);
+    IConnectableObservable<TSource> Replay<TSource>(IObservable<TSource> source, int bufferSize, TimeSpan window, IScheduler scheduler);
+    IObservable<TResult> Replay<TSource, TResult>(IObservable<TSource> source, Func<IObservable<TSource>, IObservable<TResult>> selector, int bufferSize, TimeSpan window, IScheduler scheduler);
+    IObservable<TSource> AutoConnect<TSource>(IConnectableObservable<TSource> source, int minObservers, Action<IDisposable>? onConnect);
+
+    #endregion
+
+    #region * Blocking *
+
+    IEnumerable<IList<TSource>> Chunkify<TSource>(IObservable<TSource> source);
+    IEnumerable<TResult> Collect<TSource, TResult>(IObservable<TSource> source, Func<TResult> newCollector, Func<TResult, TSource, TResult> merge);
+    IEnumerable<TResult> Collect<TSource, TResult>(IObservable<TSource> source, Func<TResult> getInitialCollector, Func<TResult, TSource, TResult> merge, Func<TResult, TResult> getNewCollector);
+    TSource First<TSource>(IObservable<TSource> source);
+    TSource First<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    [return: MaybeNull] TSource FirstOrDefault<TSource>(IObservable<TSource> source);
+    [return: MaybeNull] TSource FirstOrDefault<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    void ForEach<TSource>(IObservable<TSource> source, Action<TSource> onNext);
+    void ForEach<TSource>(IObservable<TSource> source, Action<TSource, int> onNext);
+    IEnumerator<TSource> GetEnumerator<TSource>(IObservable<TSource> source);
+    TSource Last<TSource>(IObservable<TSource> source);
+    TSource Last<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    [return: MaybeNull] TSource LastOrDefault<TSource>(IObservable<TSource> source);
+    [return: MaybeNull] TSource LastOrDefault<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IEnumerable<TSource> Latest<TSource>(IObservable<TSource> source);
+    IEnumerable<TSource> MostRecent<TSource>(IObservable<TSource> source, TSource initialValue);
+    IEnumerable<TSource> Next<TSource>(IObservable<TSource> source);
+    TSource Single<TSource>(IObservable<TSource> source);
+    [return: MaybeNull] TSource SingleOrDefault<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    [return: MaybeNull] TSource SingleOrDefault<TSource>(IObservable<TSource> source);
+    TSource Single<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    TSource Wait<TSource>(IObservable<TSource> source);
+
+    #endregion
+
+    #region * Concurrency *
+
+    IObservable<TSource> ObserveOn<TSource>(IObservable<TSource> source, IScheduler scheduler);
+    IObservable<TSource> ObserveOn<TSource>(IObservable<TSource> source, SynchronizationContext context);
+
+    IObservable<TSource> SubscribeOn<TSource>(IObservable<TSource> source, IScheduler scheduler);
+    IObservable<TSource> SubscribeOn<TSource>(IObservable<TSource> source, SynchronizationContext context);
+
+    IObservable<TSource> Synchronize<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Synchronize<TSource>(IObservable<TSource> source, object gate);
+
+    #endregion
+
+    #region * Conversions *
+
+    IDisposable Subscribe<TSource>(IEnumerable<TSource> source, IObserver<TSource> observer);
+    IDisposable Subscribe<TSource>(IEnumerable<TSource> source, IObserver<TSource> observer, IScheduler scheduler);
+    IEnumerable<TSource> ToEnumerable<TSource>(IObservable<TSource> source);
+    IEventSource<Unit> ToEvent(IObservable<Unit> source);
+    IEventSource<TSource> ToEvent<TSource>(IObservable<TSource> source);
+    IEventPatternSource<TEventArgs> ToEventPattern<TEventArgs>(IObservable<EventPattern<TEventArgs>> source);
+    IObservable<TSource> ToObservable<TSource>(IEnumerable<TSource> source);
+    IObservable<TSource> ToObservable<TSource>(IEnumerable<TSource> source, IScheduler scheduler);
+
+    #endregion
+
+    #region * Creation *
+
+    IObservable<TSource> Create<TSource>(Func<IObserver<TSource>, IDisposable> subscribe);
+    IObservable<TSource> Create<TSource>(Func<IObserver<TSource>, Action> subscribe);
+    IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task> subscribeAsync);
+    IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task> subscribeAsync);
+    IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task<IDisposable>> subscribeAsync);
+    IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<IDisposable>> subscribeAsync);
+    IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, CancellationToken, Task<Action>> subscribeAsync);
+    IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<Action>> subscribeAsync);
+
+    IObservable<TValue> Defer<TValue>(Func<IObservable<TValue>> observableFactory);
+
+    IObservable<TValue> Defer<TValue>(Func<Task<IObservable<TValue>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe);
+    IObservable<TValue> Defer<TValue>(Func<CancellationToken, Task<IObservable<TValue>>> observableFactoryAsync, bool ignoreExceptionsAfterUnsubscribe);
+
+    IObservable<TResult> Empty<TResult>();
+    IObservable<TResult> Empty<TResult>(IScheduler scheduler);
+    IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector);
+    IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, IScheduler scheduler);
+    IObservable<TResult> Never<TResult>();
+    IObservable<int> Range(int start, int count);
+    IObservable<int> Range(int start, int count, IScheduler scheduler);
+    IObservable<TResult> Repeat<TResult>(TResult value);
+    IObservable<TResult> Repeat<TResult>(TResult value, IScheduler scheduler);
+    IObservable<TResult> Repeat<TResult>(TResult value, int repeatCount);
+    IObservable<TResult> Repeat<TResult>(TResult value, int repeatCount, IScheduler scheduler);
+    IObservable<TResult> Return<TResult>(TResult value);
+    IObservable<TResult> Return<TResult>(TResult value, IScheduler scheduler);
+    IObservable<TResult> Throw<TResult>(Exception exception);
+    IObservable<TResult> Throw<TResult>(Exception exception, IScheduler scheduler);
+    IObservable<TSource> Using<TSource, TResource>(Func<TResource> resourceFactory, Func<TResource, IObservable<TSource>> observableFactory) where TResource : IDisposable;
+    IObservable<TSource> Using<TSource, TResource>(Func<CancellationToken, Task<TResource>> resourceFactoryAsync, Func<TResource, CancellationToken, Task<IObservable<TSource>>> observableFactoryAsync) where TResource : IDisposable;
+
+    #endregion
+
+    #region * Events *
+
+    IObservable<EventPattern<object>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler);
+    IObservable<EventPattern<object>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler, IScheduler scheduler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TDelegate, TEventArgs>(Func<EventHandler<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler, IScheduler scheduler);
+    IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
+    IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TDelegate, TSender, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<object>> FromEventPattern(object target, string eventName);
+    IObservable<EventPattern<object>> FromEventPattern(object target, string eventName);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<object>> FromEventPattern(object target, string eventName, IScheduler scheduler);
+    IObservable<EventPattern<object>> FromEventPattern(object target, string eventName, IScheduler scheduler);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(object target, string eventName);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(object target, string eventName);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(object target, string eventName, IScheduler scheduler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(object target, string eventName, IScheduler scheduler);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(object target, string eventName);
+    IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(object target, string eventName);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(object target, string eventName, IScheduler scheduler);
+    IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(object target, string eventName, IScheduler scheduler);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<object>> FromEventPattern(Type type, string eventName);
+    IObservable<EventPattern<object>> FromEventPattern(Type type, string eventName);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<object>> FromEventPattern(Type type, string eventName, IScheduler scheduler);
+    IObservable<EventPattern<object>> FromEventPattern(Type type, string eventName, IScheduler scheduler);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Type type, string eventName);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Type type, string eventName);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Type type, string eventName, IScheduler scheduler);
+    IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Type type, string eventName, IScheduler scheduler);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(Type type, string eventName);
+    IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(Type type, string eventName);
 #if HAS_TRIMMABILITY_ATTRIBUTES
-        [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
+    [RequiresUnreferencedCode(Constants_Core.EventReflectionTrimIncompatibilityMessage)]
 #endif
-        IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(Type type, string eventName, IScheduler scheduler);
-
-        IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
-        IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
-        IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
-        IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
-        IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler);
-        IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler, IScheduler scheduler);
-        IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler);
-        IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler, IScheduler scheduler);
-
-        #endregion
-
-        #region * Imperative *
-
-        Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource> onNext);
-        Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource> onNext, CancellationToken cancellationToken);
-        Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource, int> onNext);
-        Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource, int> onNext, CancellationToken cancellationToken);
-
-        IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IObservable<TResult> defaultSource) where TValue : notnull;
-        IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IScheduler scheduler) where TValue : notnull;
-        IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources) where TValue : notnull;
-        IObservable<TSource> DoWhile<TSource>(IObservable<TSource> source, Func<bool> condition);
-        IObservable<TResult> For<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, IObservable<TResult>> resultSelector);
-        IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource, IObservable<TResult> elseSource);
-        IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource);
-        IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource, IScheduler scheduler);
-        IObservable<TSource> While<TSource>(Func<bool> condition, IObservable<TSource> source);
-
-        #endregion
-
-        #region * Joins *
-
-        Pattern<TLeft, TRight> And<TLeft, TRight>(IObservable<TLeft> left, IObservable<TRight> right);
-        Plan<TResult> Then<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
-        IObservable<TResult> When<TResult>(params Plan<TResult>[] plans);
-        IObservable<TResult> When<TResult>(IEnumerable<Plan<TResult>> plans);
-
-        #endregion
-
-        #region * Multiple *
-
-        IObservable<TSource> Amb<TSource>(IObservable<TSource> first, IObservable<TSource> second);
-        IObservable<TSource> Amb<TSource>(params IObservable<TSource>[] sources);
-        IObservable<TSource> Amb<TSource>(IEnumerable<IObservable<TSource>> sources);
-        IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector);
-        IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector);
-        IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries);
-        IObservable<TSource> Catch<TSource, TException>(IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception;
-        IObservable<TSource> Catch<TSource>(IObservable<TSource> first, IObservable<TSource> second);
-        IObservable<TSource> Catch<TSource>(params IObservable<TSource>[] sources);
-        IObservable<TSource> Catch<TSource>(IEnumerable<IObservable<TSource>> sources);
-        // NB: N-ary overloads of CombineLatest are generated in IQueryLanguage.tt.
-        IObservable<TResult> CombineLatest<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector);
-        IObservable<IList<TSource>> CombineLatest<TSource>(IEnumerable<IObservable<TSource>> sources);
-        IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources);
-        IObservable<TSource> Concat<TSource>(IObservable<TSource> first, IObservable<TSource> second);
-        IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources);
-        IObservable<TSource> Concat<TSource>(IEnumerable<IObservable<TSource>> sources);
-        IObservable<TSource> Concat<TSource>(IObservable<IObservable<TSource>> sources);
-        IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources);
-        IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources, int maxConcurrent);
-        IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent);
-        IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler);
-        IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second);
-        IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler);
-        IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources);
-        IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources);
-        IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources);
-        IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, IScheduler scheduler);
-        IObservable<TSource> OnErrorResumeNext<TSource>(IObservable<TSource> first, IObservable<TSource> second);
-        IObservable<TSource> OnErrorResumeNext<TSource>(params IObservable<TSource>[] sources);
-        IObservable<TSource> OnErrorResumeNext<TSource>(IEnumerable<IObservable<TSource>> sources);
-        IObservable<TSource> SkipUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other);
-        IObservable<TSource> Switch<TSource>(IObservable<IObservable<TSource>> sources);
-        IObservable<TSource> TakeUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other);
-        IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, Func<TSource, bool> stopPredicate);
-        IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector);
-        IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector);
-        IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries);
-        IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector);
-        IObservable<TResult> Zip<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector);
-        IObservable<IList<TSource>> Zip<TSource>(IEnumerable<IObservable<TSource>> sources);
-        IObservable<IList<TSource>> Zip<TSource>(params IObservable<TSource>[] sources);
-        // NB: N-ary overloads of Zip are generated in IQueryLanguage.tt.
-        IObservable<TResult> Zip<TFirst, TSecond, TResult>(IObservable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector);
-
-        IObservable<TSource> Concat<TSource>(IObservable<Task<TSource>> sources);
-        IObservable<TSource> Merge<TSource>(IObservable<Task<TSource>> sources);
-        IObservable<TSource> Switch<TSource>(IObservable<Task<TSource>> sources);
-
-        #endregion
-
-        #region * Single *
-
-        IObservable<TSource> Append<TSource>(IObservable<TSource> source, TSource value);
-        IObservable<TSource> Append<TSource>(IObservable<TSource> source, TSource value, IScheduler scheduler);
-        IObservable<TSource> AsObservable<TSource>(IObservable<TSource> source);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, int count);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, int count, int skip);
-        IObservable<TSource> Dematerialize<TSource>(IObservable<Notification<TSource>> source);
-        IObservable<TSource> DistinctUntilChanged<TSource>(IObservable<TSource> source);
-        IObservable<TSource> DistinctUntilChanged<TSource>(IObservable<TSource> source, IEqualityComparer<TSource> comparer);
-        IObservable<TSource> DistinctUntilChanged<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
-        IObservable<TSource> DistinctUntilChanged<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
-        IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext);
-        IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext, Action onCompleted);
-        IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError);
-        IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted);
-        IObservable<TSource> Do<TSource>(IObservable<TSource> source, IObserver<TSource> observer);
-        IObservable<TSource> Finally<TSource>(IObservable<TSource> source, Action finallyAction);
-        IObservable<TSource> IgnoreElements<TSource>(IObservable<TSource> source);
-        IObservable<Notification<TSource>> Materialize<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Prepend<TSource>(IObservable<TSource> source, TSource value);
-        IObservable<TSource> Prepend<TSource>(IObservable<TSource> source, TSource value, IScheduler scheduler);
-        IObservable<TSource> Repeat<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Repeat<TSource>(IObservable<TSource> source, int repeatCount);
-        IObservable<TSource> RepeatWhen<TSource, TSignal>(IObservable<TSource> source, Func<IObservable<object>, IObservable<TSignal>> handler);
-        IObservable<TSource> Retry<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Retry<TSource>(IObservable<TSource> source, int retryCount);
-        IObservable<TSource> RetryWhen<TSource, TSignal>(IObservable<TSource> source, Func<IObservable<Exception>, IObservable<TSignal>> handler);
-        IObservable<TAccumulate> Scan<TSource, TAccumulate>(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator);
-        IObservable<TSource> Scan<TSource>(IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator);
-        IObservable<TSource> SkipLast<TSource>(IObservable<TSource> source, int count);
-        IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, params TSource[] values);
-        IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, IScheduler scheduler, params TSource[] values);
-        IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, IEnumerable<TSource> values);
-        IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, IScheduler scheduler, IEnumerable<TSource> values);
-        IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, int count);
-        IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, int count, IScheduler scheduler);
-        IObservable<IList<TSource>> TakeLastBuffer<TSource>(IObservable<TSource> source, int count);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, int count, int skip);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, int count);
-
-        #endregion
-
-        #region * StandardSequenceOperators *
-
-        IObservable<TResult> Cast<TResult>(IObservable<object> source);
-        IObservable<TSource?> DefaultIfEmpty<TSource>(IObservable<TSource> source);
-        IObservable<TSource> DefaultIfEmpty<TSource>(IObservable<TSource> source, TSource defaultValue);
-        IObservable<TSource> Distinct<TSource>(IObservable<TSource> source);
-        IObservable<TSource> Distinct<TSource>(IObservable<TSource> source, IEqualityComparer<TSource> comparer);
-        IObservable<TSource> Distinct<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
-        IObservable<TSource> Distinct<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, int capacity);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer);
-        IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, int capacity);
-        IObservable<TResult> GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector, Func<TRight, IObservable<TRightDuration>> rightDurationSelector, Func<TLeft, IObservable<TRight>, TResult> resultSelector);
-        IObservable<TResult> Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector, Func<TRight, IObservable<TRightDuration>> rightDurationSelector, Func<TLeft, TRight, TResult> resultSelector);
-        IObservable<TResult> OfType<TResult>(IObservable<object> source);
-        IObservable<TResult> Select<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
-        IObservable<TResult> Select<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, TResult> selector);
-        IObservable<TOther> SelectMany<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, IObservable<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
-        IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, int, IObservable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TResult>> onNext, Func<Exception, IObservable<TResult>> onError, Func<IObservable<TResult>> onCompleted);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, IObservable<TResult>> onNext, Func<Exception, IObservable<TResult>> onError, Func<IObservable<TResult>> onCompleted);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
-        IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector);
-        IObservable<TSource> Skip<TSource>(IObservable<TSource> source, int count);
-        IObservable<TSource> SkipWhile<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource> SkipWhile<TSource>(IObservable<TSource> source, Func<TSource, int, bool> predicate);
-        IObservable<TSource> Take<TSource>(IObservable<TSource> source, int count);
-        IObservable<TSource> Take<TSource>(IObservable<TSource> source, int count, IScheduler scheduler);
-        IObservable<TSource> TakeWhile<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource> TakeWhile<TSource>(IObservable<TSource> source, Func<TSource, int, bool> predicate);
-        IObservable<TSource> Where<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
-        IObservable<TSource> Where<TSource>(IObservable<TSource> source, Func<TSource, int, bool> predicate);
-
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, Task<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, CancellationToken, Task<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TResult>> selector);
-        IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, Task<TTaskResult>> taskSelector, Func<TSource, TTaskResult, TResult> resultSelector);
-        IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, int, Task<TTaskResult>> taskSelector, Func<TSource, int, TTaskResult, TResult> resultSelector);
-        IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, CancellationToken, Task<TTaskResult>> taskSelector, Func<TSource, TTaskResult, TResult> resultSelector);
-        IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TTaskResult>> taskSelector, Func<TSource, int, TTaskResult, TResult> resultSelector);
-
-        #endregion
-
-        #region * Time *
-
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, IScheduler scheduler);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count);
-        IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count, IScheduler scheduler);
-        IObservable<TSource> Delay<TSource>(IObservable<TSource> source, TimeSpan dueTime);
-        IObservable<TSource> Delay<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
-        IObservable<TSource> Delay<TSource>(IObservable<TSource> source, DateTimeOffset dueTime);
-        IObservable<TSource> Delay<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler);
-        IObservable<TSource> Delay<TSource, TDelay>(IObservable<TSource> source, Func<TSource, IObservable<TDelay>> delayDurationSelector);
-        IObservable<TSource> Delay<TSource, TDelay>(IObservable<TSource> source, IObservable<TDelay> subscriptionDelay, Func<TSource, IObservable<TDelay>> delayDurationSelector);
-        IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, TimeSpan dueTime);
-        IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
-        IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, DateTimeOffset dueTime);
-        IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler);
-        IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, TimeSpan> timeSelector);
-        IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, TimeSpan> timeSelector, IScheduler scheduler);
-        IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, DateTimeOffset> timeSelector);
-        IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, DateTimeOffset> timeSelector, IScheduler scheduler);
-        IObservable<long> Interval(TimeSpan period);
-        IObservable<long> Interval(TimeSpan period, IScheduler scheduler);
-        IObservable<TSource> Sample<TSource>(IObservable<TSource> source, TimeSpan interval);
-        IObservable<TSource> Sample<TSource>(IObservable<TSource> source, TimeSpan interval, IScheduler scheduler);
-        IObservable<TSource> Sample<TSource, TSample>(IObservable<TSource> source, IObservable<TSample> sampler);
-        IObservable<TSource> Skip<TSource>(IObservable<TSource> source, TimeSpan duration);
-        IObservable<TSource> Skip<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
-        IObservable<TSource> SkipLast<TSource>(IObservable<TSource> source, TimeSpan duration);
-        IObservable<TSource> SkipLast<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
-        IObservable<TSource> SkipUntil<TSource>(IObservable<TSource> source, DateTimeOffset startTime);
-        IObservable<TSource> SkipUntil<TSource>(IObservable<TSource> source, DateTimeOffset startTime, IScheduler scheduler);
-        IObservable<TSource> Take<TSource>(IObservable<TSource> source, TimeSpan duration);
-        IObservable<TSource> Take<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
-        IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, TimeSpan duration);
-        IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
-        IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler timerScheduler, IScheduler loopScheduler);
-        IObservable<IList<TSource>> TakeLastBuffer<TSource>(IObservable<TSource> source, TimeSpan duration);
-        IObservable<IList<TSource>> TakeLastBuffer<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
-        IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, DateTimeOffset endTime);
-        IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, DateTimeOffset endTime, IScheduler scheduler);
-        IObservable<TSource> Throttle<TSource>(IObservable<TSource> source, TimeSpan dueTime);
-        IObservable<TSource> Throttle<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
-        IObservable<TSource> Throttle<TSource, TThrottle>(IObservable<TSource> source, Func<TSource, IObservable<TThrottle>> throttleDurationSelector);
-        IObservable<TimeInterval<TSource>> TimeInterval<TSource>(IObservable<TSource> source);
-        IObservable<TimeInterval<TSource>> TimeInterval<TSource>(IObservable<TSource> source, IScheduler scheduler);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime, IObservable<TSource> other);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime, IObservable<TSource> other, IScheduler scheduler);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IObservable<TSource> other);
-        IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IObservable<TSource> other, IScheduler scheduler);
-        IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector);
-        IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector, IObservable<TSource> other);
-        IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, IObservable<TTimeout> firstTimeout, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector);
-        IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, IObservable<TTimeout> firstTimeout, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector, IObservable<TSource> other);
-        IObservable<long> Timer(TimeSpan dueTime);
-        IObservable<long> Timer(DateTimeOffset dueTime);
-        IObservable<long> Timer(TimeSpan dueTime, TimeSpan period);
-        IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period);
-        IObservable<long> Timer(TimeSpan dueTime, IScheduler scheduler);
-        IObservable<long> Timer(DateTimeOffset dueTime, IScheduler scheduler);
-        IObservable<long> Timer(TimeSpan dueTime, TimeSpan period, IScheduler scheduler);
-        IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period, IScheduler scheduler);
-        IObservable<Timestamped<TSource>> Timestamp<TSource>(IObservable<TSource> source);
-        IObservable<Timestamped<TSource>> Timestamp<TSource>(IObservable<TSource> source, IScheduler scheduler);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, IScheduler scheduler);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count);
-        IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count, IScheduler scheduler);
-
-        #endregion
-    }
+    IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TSender, TEventArgs>(Type type, string eventName, IScheduler scheduler);
+
+    IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
+    IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Func<Action<TEventArgs>, TDelegate> conversion, Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
+    IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler);
+    IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, IScheduler scheduler);
+    IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler);
+    IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler, IScheduler scheduler);
+    IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler);
+    IObservable<Unit> FromEvent(Action<Action> addHandler, Action<Action> removeHandler, IScheduler scheduler);
+
+    #endregion
+
+    #region * Imperative *
+
+    Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource> onNext);
+    Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource> onNext, CancellationToken cancellationToken);
+    Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource, int> onNext);
+    Task ForEachAsync<TSource>(IObservable<TSource> source, Action<TSource, int> onNext, CancellationToken cancellationToken);
+
+    IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IObservable<TResult> defaultSource) where TValue : notnull;
+    IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IScheduler scheduler) where TValue : notnull;
+    IObservable<TResult> Case<TValue, TResult>(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources) where TValue : notnull;
+    IObservable<TSource> DoWhile<TSource>(IObservable<TSource> source, Func<bool> condition);
+    IObservable<TResult> For<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, IObservable<TResult>> resultSelector);
+    IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource, IObservable<TResult> elseSource);
+    IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource);
+    IObservable<TResult> If<TResult>(Func<bool> condition, IObservable<TResult> thenSource, IScheduler scheduler);
+    IObservable<TSource> While<TSource>(Func<bool> condition, IObservable<TSource> source);
+
+    #endregion
+
+    #region * Joins *
+
+    Pattern<TLeft, TRight> And<TLeft, TRight>(IObservable<TLeft> left, IObservable<TRight> right);
+    Plan<TResult> Then<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
+    IObservable<TResult> When<TResult>(params Plan<TResult>[] plans);
+    IObservable<TResult> When<TResult>(IEnumerable<Plan<TResult>> plans);
+
+    #endregion
+
+    #region * Multiple *
+
+    IObservable<TSource> Amb<TSource>(IObservable<TSource> first, IObservable<TSource> second);
+    IObservable<TSource> Amb<TSource>(params IObservable<TSource>[] sources);
+    IObservable<TSource> Amb<TSource>(IEnumerable<IObservable<TSource>> sources);
+    IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector);
+    IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector);
+    IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries);
+    IObservable<TSource> Catch<TSource, TException>(IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception;
+    IObservable<TSource> Catch<TSource>(IObservable<TSource> first, IObservable<TSource> second);
+    IObservable<TSource> Catch<TSource>(params IObservable<TSource>[] sources);
+    IObservable<TSource> Catch<TSource>(IEnumerable<IObservable<TSource>> sources);
+    // NB: N-ary overloads of CombineLatest are generated in IQueryLanguage.tt.
+    IObservable<TResult> CombineLatest<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector);
+    IObservable<IList<TSource>> CombineLatest<TSource>(IEnumerable<IObservable<TSource>> sources);
+    IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources);
+    IObservable<TSource> Concat<TSource>(IObservable<TSource> first, IObservable<TSource> second);
+    IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources);
+    IObservable<TSource> Concat<TSource>(IEnumerable<IObservable<TSource>> sources);
+    IObservable<TSource> Concat<TSource>(IObservable<IObservable<TSource>> sources);
+    IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources);
+    IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources, int maxConcurrent);
+    IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent);
+    IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler);
+    IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second);
+    IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler);
+    IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources);
+    IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources);
+    IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources);
+    IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, IScheduler scheduler);
+    IObservable<TSource> OnErrorResumeNext<TSource>(IObservable<TSource> first, IObservable<TSource> second);
+    IObservable<TSource> OnErrorResumeNext<TSource>(params IObservable<TSource>[] sources);
+    IObservable<TSource> OnErrorResumeNext<TSource>(IEnumerable<IObservable<TSource>> sources);
+    IObservable<TSource> SkipUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other);
+    IObservable<TSource> Switch<TSource>(IObservable<IObservable<TSource>> sources);
+    IObservable<TSource> TakeUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other);
+    IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, Func<TSource, bool> stopPredicate);
+    IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, CancellationToken cancellationToken);
+    IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector);
+    IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector);
+    IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries);
+    IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector);
+    IObservable<TResult> Zip<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector);
+    IObservable<IList<TSource>> Zip<TSource>(IEnumerable<IObservable<TSource>> sources);
+    IObservable<IList<TSource>> Zip<TSource>(params IObservable<TSource>[] sources);
+    // NB: N-ary overloads of Zip are generated in IQueryLanguage.tt.
+    IObservable<TResult> Zip<TFirst, TSecond, TResult>(IObservable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector);
+
+    IObservable<TSource> Concat<TSource>(IObservable<Task<TSource>> sources);
+    IObservable<TSource> Merge<TSource>(IObservable<Task<TSource>> sources);
+    IObservable<TSource> Switch<TSource>(IObservable<Task<TSource>> sources);
+
+    #endregion
+
+    #region * Single *
+
+    IObservable<TSource> Append<TSource>(IObservable<TSource> source, TSource value);
+    IObservable<TSource> Append<TSource>(IObservable<TSource> source, TSource value, IScheduler scheduler);
+    IObservable<TSource> AsObservable<TSource>(IObservable<TSource> source);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, int count);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, int count, int skip);
+    IObservable<TSource> Dematerialize<TSource>(IObservable<Notification<TSource>> source);
+    IObservable<TSource> DistinctUntilChanged<TSource>(IObservable<TSource> source);
+    IObservable<TSource> DistinctUntilChanged<TSource>(IObservable<TSource> source, IEqualityComparer<TSource> comparer);
+    IObservable<TSource> DistinctUntilChanged<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
+    IObservable<TSource> DistinctUntilChanged<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
+    IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext);
+    IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext, Action onCompleted);
+    IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError);
+    IObservable<TSource> Do<TSource>(IObservable<TSource> source, Action<TSource> onNext, Action<Exception> onError, Action onCompleted);
+    IObservable<TSource> Do<TSource>(IObservable<TSource> source, IObserver<TSource> observer);
+    IObservable<TSource> Finally<TSource>(IObservable<TSource> source, Action finallyAction);
+    IObservable<TSource> IgnoreElements<TSource>(IObservable<TSource> source);
+    IObservable<Notification<TSource>> Materialize<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Prepend<TSource>(IObservable<TSource> source, TSource value);
+    IObservable<TSource> Prepend<TSource>(IObservable<TSource> source, TSource value, IScheduler scheduler);
+    IObservable<TSource> Repeat<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Repeat<TSource>(IObservable<TSource> source, int repeatCount);
+    IObservable<TSource> RepeatWhen<TSource, TSignal>(IObservable<TSource> source, Func<IObservable<object>, IObservable<TSignal>> handler);
+    IObservable<TSource> Retry<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Retry<TSource>(IObservable<TSource> source, int retryCount);
+    IObservable<TSource> RetryWhen<TSource, TSignal>(IObservable<TSource> source, Func<IObservable<Exception>, IObservable<TSignal>> handler);
+    IObservable<TAccumulate> Scan<TSource, TAccumulate>(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator);
+    IObservable<TSource> Scan<TSource>(IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator);
+    IObservable<TSource> SkipLast<TSource>(IObservable<TSource> source, int count);
+    IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, params TSource[] values);
+    IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, IScheduler scheduler, params TSource[] values);
+    IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, IEnumerable<TSource> values);
+    IObservable<TSource> StartWith<TSource>(IObservable<TSource> source, IScheduler scheduler, IEnumerable<TSource> values);
+    IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, int count);
+    IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, int count, IScheduler scheduler);
+    IObservable<IList<TSource>> TakeLastBuffer<TSource>(IObservable<TSource> source, int count);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, int count, int skip);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, int count);
+
+    #endregion
+
+    #region * StandardSequenceOperators *
+
+    IObservable<TResult> Cast<TResult>(IObservable<object> source);
+    IObservable<TSource?> DefaultIfEmpty<TSource>(IObservable<TSource> source);
+    IObservable<TSource> DefaultIfEmpty<TSource>(IObservable<TSource> source, TSource defaultValue);
+    IObservable<TSource> Distinct<TSource>(IObservable<TSource> source);
+    IObservable<TSource> Distinct<TSource>(IObservable<TSource> source, IEqualityComparer<TSource> comparer);
+    IObservable<TSource> Distinct<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
+    IObservable<TSource> Distinct<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupBy<TSource, TKey>(IObservable<TSource> source, Func<TSource, TKey> keySelector, int capacity);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupBy<TSource, TKey, TElement>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, int capacity, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TElement>> GroupByUntil<TSource, TKey, TElement, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>> durationSelector, int capacity);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, int capacity, IEqualityComparer<TKey> comparer);
+    IObservable<IGroupedObservable<TKey, TSource>> GroupByUntil<TSource, TKey, TDuration>(IObservable<TSource> source, Func<TSource, TKey> keySelector, Func<IGroupedObservable<TKey, TSource>, IObservable<TDuration>> durationSelector, int capacity);
+    IObservable<TResult> GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector, Func<TRight, IObservable<TRightDuration>> rightDurationSelector, Func<TLeft, IObservable<TRight>, TResult> resultSelector);
+    IObservable<TResult> Join<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector, Func<TRight, IObservable<TRightDuration>> rightDurationSelector, Func<TLeft, TRight, TResult> resultSelector);
+    IObservable<TResult> OfType<TResult>(IObservable<object> source);
+    IObservable<TResult> Select<TSource, TResult>(IObservable<TSource> source, Func<TSource, TResult> selector);
+    IObservable<TResult> Select<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, TResult> selector);
+    IObservable<TOther> SelectMany<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, IObservable<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
+    IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, int, IObservable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, IObservable<TResult>> onNext, Func<Exception, IObservable<TResult>> onError, Func<IObservable<TResult>> onCompleted);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, IObservable<TResult>> onNext, Func<Exception, IObservable<TResult>> onError, Func<IObservable<TResult>> onCompleted);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
+    IObservable<TResult> SelectMany<TSource, TCollection, TResult>(IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector);
+    IObservable<TSource> Skip<TSource>(IObservable<TSource> source, int count);
+    IObservable<TSource> SkipWhile<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource> SkipWhile<TSource>(IObservable<TSource> source, Func<TSource, int, bool> predicate);
+    IObservable<TSource> Take<TSource>(IObservable<TSource> source, int count);
+    IObservable<TSource> Take<TSource>(IObservable<TSource> source, int count, IScheduler scheduler);
+    IObservable<TSource> TakeWhile<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource> TakeWhile<TSource>(IObservable<TSource> source, Func<TSource, int, bool> predicate);
+    IObservable<TSource> Where<TSource>(IObservable<TSource> source, Func<TSource, bool> predicate);
+    IObservable<TSource> Where<TSource>(IObservable<TSource> source, Func<TSource, int, bool> predicate);
+
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, Task<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, Task<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, CancellationToken, Task<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TResult>(IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TResult>> selector);
+    IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, Task<TTaskResult>> taskSelector, Func<TSource, TTaskResult, TResult> resultSelector);
+    IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, int, Task<TTaskResult>> taskSelector, Func<TSource, int, TTaskResult, TResult> resultSelector);
+    IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, CancellationToken, Task<TTaskResult>> taskSelector, Func<TSource, TTaskResult, TResult> resultSelector);
+    IObservable<TResult> SelectMany<TSource, TTaskResult, TResult>(IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TTaskResult>> taskSelector, Func<TSource, int, TTaskResult, TResult> resultSelector);
+
+    #endregion
+
+    #region * Time *
+
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, IScheduler scheduler);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count);
+    IObservable<IList<TSource>> Buffer<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count, IScheduler scheduler);
+    IObservable<TSource> Delay<TSource>(IObservable<TSource> source, TimeSpan dueTime);
+    IObservable<TSource> Delay<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
+    IObservable<TSource> Delay<TSource>(IObservable<TSource> source, DateTimeOffset dueTime);
+    IObservable<TSource> Delay<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler);
+    IObservable<TSource> Delay<TSource, TDelay>(IObservable<TSource> source, Func<TSource, IObservable<TDelay>> delayDurationSelector);
+    IObservable<TSource> Delay<TSource, TDelay>(IObservable<TSource> source, IObservable<TDelay> subscriptionDelay, Func<TSource, IObservable<TDelay>> delayDurationSelector);
+    IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, TimeSpan dueTime);
+    IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
+    IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, DateTimeOffset dueTime);
+    IObservable<TSource> DelaySubscription<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler);
+    IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, TimeSpan> timeSelector);
+    IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, TimeSpan> timeSelector, IScheduler scheduler);
+    IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, DateTimeOffset> timeSelector);
+    IObservable<TResult> Generate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector, Func<TState, DateTimeOffset> timeSelector, IScheduler scheduler);
+    IObservable<long> Interval(TimeSpan period);
+    IObservable<long> Interval(TimeSpan period, IScheduler scheduler);
+    IObservable<TSource> Sample<TSource>(IObservable<TSource> source, TimeSpan interval);
+    IObservable<TSource> Sample<TSource>(IObservable<TSource> source, TimeSpan interval, IScheduler scheduler);
+    IObservable<TSource> Sample<TSource, TSample>(IObservable<TSource> source, IObservable<TSample> sampler);
+    IObservable<TSource> Skip<TSource>(IObservable<TSource> source, TimeSpan duration);
+    IObservable<TSource> Skip<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
+    IObservable<TSource> SkipLast<TSource>(IObservable<TSource> source, TimeSpan duration);
+    IObservable<TSource> SkipLast<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
+    IObservable<TSource> SkipUntil<TSource>(IObservable<TSource> source, DateTimeOffset startTime);
+    IObservable<TSource> SkipUntil<TSource>(IObservable<TSource> source, DateTimeOffset startTime, IScheduler scheduler);
+    IObservable<TSource> Take<TSource>(IObservable<TSource> source, TimeSpan duration);
+    IObservable<TSource> Take<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
+    IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, TimeSpan duration);
+    IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
+    IObservable<TSource> TakeLast<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler timerScheduler, IScheduler loopScheduler);
+    IObservable<IList<TSource>> TakeLastBuffer<TSource>(IObservable<TSource> source, TimeSpan duration);
+    IObservable<IList<TSource>> TakeLastBuffer<TSource>(IObservable<TSource> source, TimeSpan duration, IScheduler scheduler);
+    IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, DateTimeOffset endTime);
+    IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, DateTimeOffset endTime, IScheduler scheduler);
+    IObservable<TSource> Throttle<TSource>(IObservable<TSource> source, TimeSpan dueTime);
+    IObservable<TSource> Throttle<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
+    IObservable<TSource> Throttle<TSource, TThrottle>(IObservable<TSource> source, Func<TSource, IObservable<TThrottle>> throttleDurationSelector);
+    IObservable<TimeInterval<TSource>> TimeInterval<TSource>(IObservable<TSource> source);
+    IObservable<TimeInterval<TSource>> TimeInterval<TSource>(IObservable<TSource> source, IScheduler scheduler);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime, IObservable<TSource> other);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, TimeSpan dueTime, IObservable<TSource> other, IScheduler scheduler);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IObservable<TSource> other);
+    IObservable<TSource> Timeout<TSource>(IObservable<TSource> source, DateTimeOffset dueTime, IObservable<TSource> other, IScheduler scheduler);
+    IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector);
+    IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector, IObservable<TSource> other);
+    IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, IObservable<TTimeout> firstTimeout, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector);
+    IObservable<TSource> Timeout<TSource, TTimeout>(IObservable<TSource> source, IObservable<TTimeout> firstTimeout, Func<TSource, IObservable<TTimeout>> timeoutDurationSelector, IObservable<TSource> other);
+    IObservable<long> Timer(TimeSpan dueTime);
+    IObservable<long> Timer(DateTimeOffset dueTime);
+    IObservable<long> Timer(TimeSpan dueTime, TimeSpan period);
+    IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period);
+    IObservable<long> Timer(TimeSpan dueTime, IScheduler scheduler);
+    IObservable<long> Timer(DateTimeOffset dueTime, IScheduler scheduler);
+    IObservable<long> Timer(TimeSpan dueTime, TimeSpan period, IScheduler scheduler);
+    IObservable<long> Timer(DateTimeOffset dueTime, TimeSpan period, IScheduler scheduler);
+    IObservable<Timestamped<TSource>> Timestamp<TSource>(IObservable<TSource> source);
+    IObservable<Timestamped<TSource>> Timestamp<TSource>(IObservable<TSource> source, IScheduler scheduler);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, IScheduler scheduler);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, TimeSpan timeShift, IScheduler scheduler);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count);
+    IObservable<IObservable<TSource>> Window<TSource>(IObservable<TSource> source, TimeSpan timeSpan, int count, IScheduler scheduler);
+
+    #endregion
 }
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.cs
index 865f791dd..53b6be6c0 100644
--- a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.cs
+++ b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Multiple.cs
@@ -2,1182 +2,1199 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
+namespace System.Reactive.Linq;
+
 using System.Collections.Generic;
-using System.Configuration;
 using System.Reactive.Concurrency;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace System.Reactive.Linq
+public static partial class Observable
 {
-    public static partial class Observable
+    #region + Amb +
+
+    /// <summary>
+    /// Propagates the observable sequence that reacts first.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="first">First observable sequence.</param>
+    /// <param name="second">Second observable sequence.</param>
+    /// <returns>An observable sequence that surfaces either of the given sequences, whichever reacted first.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    [Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Amb", Justification = "In honor of McCarthy.")]
+    public static IObservable<TSource> Amb<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        return s_impl.Amb(first, second);
+    }
+
+    /// <summary>
+    /// Propagates the observable sequence that reacts first.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sources competing to react first.</param>
+    /// <returns>An observable sequence that surfaces any of the given sequences, whichever reacted first.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    [Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Amb", Justification = "In honor of McCarthy.")]
+    public static IObservable<TSource> Amb<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Amb(sources);
+    }
+
+    /// <summary>
+    /// Propagates the observable sequence that reacts first.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sources competing to react first.</param>
+    /// <returns>An observable sequence that surfaces any of the given sequences, whichever reacted first.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    [Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Amb", Justification = "In honor of McCarthy.")]
+    public static IObservable<TSource> Amb<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Amb(sources);
+    }
+
+    #endregion
+
+    #region + Buffer +
+
+    /// <summary>
+    /// Projects each element of an observable sequence into consecutive non-overlapping buffers.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence, and in the lists in the result sequence.</typeparam>
+    /// <typeparam name="TBufferClosing">The type of the elements in the sequences indicating buffer closing events.</typeparam>
+    /// <param name="source">Source sequence to produce buffers over.</param>
+    /// <param name="bufferClosingSelector">A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed.</param>
+    /// <returns>An observable sequence of buffers.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="bufferClosingSelector"/> is null.</exception>
+    public static IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(this IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (bufferClosingSelector == null)
+        {
+            throw new ArgumentNullException(nameof(bufferClosingSelector));
+        }
+
+        return s_impl.Buffer(source, bufferClosingSelector);
+    }
+
+    /// <summary>
+    /// Projects each element of an observable sequence into zero or more buffers.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence, and in the lists in the result sequence.</typeparam>
+    /// <typeparam name="TBufferOpening">The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events.</typeparam>
+    /// <typeparam name="TBufferClosing">The type of the elements in the sequences indicating buffer closing events.</typeparam>
+    /// <param name="source">Source sequence to produce buffers over.</param>
+    /// <param name="bufferOpenings">Observable sequence whose elements denote the creation of new buffers.</param>
+    /// <param name="bufferClosingSelector">A function invoked to define the closing of each produced buffer.</param>
+    /// <returns>An observable sequence of buffers.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="bufferOpenings"/> or <paramref name="bufferClosingSelector"/> is null.</exception>
+    public static IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(this IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (bufferOpenings == null)
+        {
+            throw new ArgumentNullException(nameof(bufferOpenings));
+        }
+
+        if (bufferClosingSelector == null)
+        {
+            throw new ArgumentNullException(nameof(bufferClosingSelector));
+        }
+
+        return s_impl.Buffer(source, bufferOpenings, bufferClosingSelector);
+    }
+
+    /// <summary>
+    /// Projects each element of an observable sequence into consecutive non-overlapping buffers.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence, and in the lists in the result sequence.</typeparam>
+    /// <typeparam name="TBufferBoundary">The type of the elements in the sequences indicating buffer boundary events.</typeparam>
+    /// <param name="source">Source sequence to produce buffers over.</param>
+    /// <param name="bufferBoundaries">Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker.</param>
+    /// <returns>An observable sequence of buffers.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="bufferBoundaries"/> is null.</exception>
+    public static IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(this IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (bufferBoundaries == null)
+        {
+            throw new ArgumentNullException(nameof(bufferBoundaries));
+        }
+
+        return s_impl.Buffer(source, bufferBoundaries);
+    }
+
+    #endregion
+
+    #region + Catch +
+
+    /// <summary>
+    /// Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence and sequences returned by the exception handler function.</typeparam>
+    /// <typeparam name="TException">The type of the exception to catch and handle. Needs to derive from <see cref="Exception"/>.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="handler">Exception handler function, producing another observable sequence.</param>
+    /// <returns>An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="handler"/> is null.</exception>
+    public static IObservable<TSource> Catch<TSource, TException>(this IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (handler == null)
+        {
+            throw new ArgumentNullException(nameof(handler));
+        }
+
+        return s_impl.Catch(source, handler);
+    }
+
+    /// <summary>
+    /// Continues an observable sequence that is terminated by an exception with the next observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence and handler sequence.</typeparam>
+    /// <param name="first">First observable sequence whose exception (if any) is caught.</param>
+    /// <param name="second">Second observable sequence used to produce results when an error occurred in the first sequence.</param>
+    /// <returns>An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    public static IObservable<TSource> Catch<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        return s_impl.Catch(first, second);
+    }
+
+    /// <summary>
+    /// Continues an observable sequence that is terminated by an exception with the next observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source and handler sequences.</typeparam>
+    /// <param name="sources">Observable sequences to catch exceptions for.</param>
+    /// <returns>An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Catch<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Catch(sources);
+    }
+
+    /// <summary>
+    /// Continues an observable sequence that is terminated by an exception with the next observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source and handler sequences.</typeparam>
+    /// <param name="sources">Observable sequences to catch exceptions for.</param>
+    /// <returns>An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Catch<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Catch(sources);
+    }
+
+    #endregion
+
+    #region + CombineLatest +
+
+    /// <summary>
+    /// Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element.
+    /// </summary>
+    /// <typeparam name="TSource1">The type of the elements in the first source sequence.</typeparam>
+    /// <typeparam name="TSource2">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 observable source.</param>
+    /// <param name="second">Second observable source.</param>
+    /// <param name="resultSelector">Function to invoke whenever either of the sources produces an element.</param>
+    /// <returns>An observable sequence containing the result of combining elements of both sources using the specified result selector function.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="resultSelector"/> is null.</exception>
+    /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
+    public static IObservable<TResult> CombineLatest<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IObservable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        if (resultSelector == null)
+        {
+            throw new ArgumentNullException(nameof(resultSelector));
+        }
+
+        return s_impl.CombineLatest(first, second, resultSelector);
+    }
+
+    /// <summary>
+    /// Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <typeparam name="TResult">The type of the elements in the result sequence, returned by the selector function.</typeparam>
+    /// <param name="sources">Observable sources.</param>
+    /// <param name="resultSelector">Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call.</param>
+    /// <returns>An observable sequence containing the result of combining elements of the sources using the specified result selector function.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="resultSelector"/> is null.</exception>
+    /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
+    public static IObservable<TResult> CombineLatest<TSource, TResult>(this IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        if (resultSelector == null)
+        {
+            throw new ArgumentNullException(nameof(resultSelector));
+        }
+
+        return s_impl.CombineLatest(sources, resultSelector);
+    }
+
+    /// <summary>
+    /// Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
+    /// <param name="sources">Observable sources.</param>
+    /// <returns>An observable sequence containing lists of the latest elements of the sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
+    public static IObservable<IList<TSource>> CombineLatest<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.CombineLatest(sources);
+    }
+
+    /// <summary>
+    /// Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
+    /// <param name="sources">Observable sources.</param>
+    /// <returns>An observable sequence containing lists of the latest elements of the sources.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
+    public static IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.CombineLatest(sources);
+    }
+
+    #endregion
+
+    #region + Concat +
+
+    /// <summary>
+    /// Concatenates the second observable sequence to the first observable sequence upon successful termination of the first.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="first">First observable sequence.</param>
+    /// <param name="second">Second observable sequence.</param>
+    /// <returns>An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    public static IObservable<TSource> Concat<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        return s_impl.Concat(first, second);
+    }
+
+    /// <summary>
+    /// Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequences to concatenate.</param>
+    /// <returns>An observable sequence that contains the elements of each given sequence, in sequential order.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Concat(sources);
+    }
+
+    /// <summary>
+    /// Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequences to concatenate.</param>
+    /// <returns>An observable sequence that contains the elements of each given sequence, in sequential order.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Concat<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Concat(sources);
+    }
+
+    /// <summary>
+    /// Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequence of inner observable sequences.</param>
+    /// <returns>An observable sequence that contains the elements of each observed inner sequence, in sequential order.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Concat<TSource>(this IObservable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Concat(sources);
+    }
+
+    /// <summary>
+    /// Concatenates all task results, as long as the previous task terminated successfully.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the results produced by the tasks.</typeparam>
+    /// <param name="sources">Observable sequence of tasks.</param>
+    /// <returns>An observable sequence that contains the results of each task, in sequential order.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <remarks>If the tasks support cancellation, consider manual conversion of the tasks using <see cref="Observable.FromAsync{TSource}(Func{CancellationToken, Task{TSource}})"/>, followed by a concatenation operation using <see cref="Observable.Concat{TSource}(IObservable{IObservable{TSource}})"/>.</remarks>
+    public static IObservable<TSource> Concat<TSource>(this IObservable<Task<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Concat(sources);
+    }
+
+    #endregion
+
+    #region + Merge +
+
+    /// <summary>
+    /// Merges elements from all inner observable sequences into a single observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequence of inner observable sequences.</param>
+    /// <returns>The observable sequence that merges the elements of the inner sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IObservable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Merge(sources);
+    }
+
+    /// <summary>
+    /// Merges results from all source tasks into a single observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the results produced by the source tasks.</typeparam>
+    /// <param name="sources">Observable sequence of tasks.</param>
+    /// <returns>The observable sequence that merges the results of the source tasks.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <remarks>If the tasks support cancellation, consider manual conversion of the tasks using <see cref="Observable.FromAsync{TSource}(Func{CancellationToken, Task{TSource}})"/>, followed by a merge operation using <see cref="Observable.Merge{TSource}(IObservable{IObservable{TSource}})"/>.</remarks>
+    public static IObservable<TSource> Merge<TSource>(this IObservable<Task<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Merge(sources);
+    }
+
+    /// <summary>
+    /// Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequence of inner observable sequences.</param>
+    /// <param name="maxConcurrent">Maximum number of inner observable sequences being subscribed to concurrently.</param>
+    /// <returns>The observable sequence that merges the elements of the inner sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConcurrent"/> is less than or equal to zero.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IObservable<IObservable<TSource>> sources, int maxConcurrent)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        if (maxConcurrent <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(maxConcurrent));
+        }
+
+        return s_impl.Merge(sources, maxConcurrent);
+    }
+
+    /// <summary>
+    /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Enumerable sequence of observable sequences.</param>
+    /// <param name="maxConcurrent">Maximum number of observable sequences being subscribed to concurrently.</param>
+    /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConcurrent"/> is less than or equal to zero.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        if (maxConcurrent <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(maxConcurrent));
+        }
+
+        return s_impl.Merge(sources, maxConcurrent);
+    }
+
+    /// <summary>
+    /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Enumerable sequence of observable sequences.</param>
+    /// <param name="maxConcurrent">Maximum number of observable sequences being subscribed to concurrently.</param>
+    /// <param name="scheduler">Scheduler to run the enumeration of the sequence of sources on.</param>
+    /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="scheduler"/> is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConcurrent"/> is less than or equal to zero.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        if (maxConcurrent <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(maxConcurrent));
+        }
+
+        if (scheduler == null)
+        {
+            throw new ArgumentNullException(nameof(scheduler));
+        }
+
+        return s_impl.Merge(sources, maxConcurrent, scheduler);
+    }
+
+    /// <summary>
+    /// Merges elements from two observable sequences into a single observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="first">First observable sequence.</param>
+    /// <param name="second">Second observable sequence.</param>
+    /// <returns>The observable sequence that merges the elements of the given sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        return s_impl.Merge(first, second);
+    }
+
+    /// <summary>
+    /// Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="first">First observable sequence.</param>
+    /// <param name="second">Second observable sequence.</param>
+    /// <param name="scheduler">Scheduler used to introduce concurrency for making subscriptions to the given sequences.</param>
+    /// <returns>The observable sequence that merges the elements of the given sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="scheduler"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        if (scheduler == null)
+        {
+            throw new ArgumentNullException(nameof(scheduler));
+        }
+
+        return s_impl.Merge(first, second, scheduler);
+    }
+
+    /// <summary>
+    /// Merges elements from all of the specified observable sequences into a single observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequences.</param>
+    /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Merge(sources);
+    }
+
+    /// <summary>
+    /// Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequences.</param>
+    /// <param name="scheduler">Scheduler to run the enumeration of the sequence of sources on.</param>
+    /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> or <paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources)
+    {
+        if (scheduler == null)
+        {
+            throw new ArgumentNullException(nameof(scheduler));
+        }
+
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Merge(scheduler, sources);
+    }
+
+    /// <summary>
+    /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Enumerable sequence of observable sequences.</param>
+    /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Merge(sources);
+    }
+
+    /// <summary>
+    /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Enumerable sequence of observable sequences.</param>
+    /// <param name="scheduler">Scheduler to run the enumeration of the sequence of sources on.</param>
+    /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="scheduler"/> is null.</exception>
+    public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, IScheduler scheduler)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        if (scheduler == null)
+        {
+            throw new ArgumentNullException(nameof(scheduler));
+        }
+
+        return s_impl.Merge(sources, scheduler);
+    }
+
+    #endregion
+
+    #region + OnErrorResumeNext +
+
+    /// <summary>
+    /// Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="first">First observable sequence whose exception (if any) is caught.</param>
+    /// <param name="second">Second observable sequence used to produce results after the first sequence terminates.</param>
+    /// <returns>An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    public static IObservable<TSource> OnErrorResumeNext<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        return s_impl.OnErrorResumeNext(first, second);
+    }
+
+    /// <summary>
+    /// Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequences to concatenate.</param>
+    /// <returns>An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> OnErrorResumeNext<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.OnErrorResumeNext(sources);
+    }
+
+    /// <summary>
+    /// Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequences to concatenate.</param>
+    /// <returns>An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> OnErrorResumeNext<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.OnErrorResumeNext(sources);
+    }
+
+    #endregion
+
+    #region + SkipUntil +
+
+    /// <summary>
+    /// Returns the elements from the source observable sequence only after the other observable sequence produces an element.
+    /// Starting from Rx.NET 4.0, this will subscribe to <paramref name="other"/> before subscribing to <paramref name="source" />
+    /// so in case <paramref name="other" /> emits an element right away, elements from <paramref name="source" /> are not missed.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+    /// <typeparam name="TOther">The type of the elements in the other sequence that indicates the end of skip behavior.</typeparam>
+    /// <param name="source">Source sequence to propagate elements for.</param>
+    /// <param name="other">Observable sequence that triggers propagation of elements of the source sequence.</param>
+    /// <returns>An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="other"/> is null.</exception>
+    public static IObservable<TSource> SkipUntil<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)
     {
-        #region + Amb +
-
-        /// <summary>
-        /// Propagates the observable sequence that reacts first.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="first">First observable sequence.</param>
-        /// <param name="second">Second observable sequence.</param>
-        /// <returns>An observable sequence that surfaces either of the given sequences, whichever reacted first.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        [Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Amb", Justification = "In honor of McCarthy.")]
-        public static IObservable<TSource> Amb<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.Amb(first, second);
-        }
-
-        /// <summary>
-        /// Propagates the observable sequence that reacts first.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sources competing to react first.</param>
-        /// <returns>An observable sequence that surfaces any of the given sequences, whichever reacted first.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        [Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Amb", Justification = "In honor of McCarthy.")]
-        public static IObservable<TSource> Amb<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Amb(sources);
-        }
-
-        /// <summary>
-        /// Propagates the observable sequence that reacts first.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sources competing to react first.</param>
-        /// <returns>An observable sequence that surfaces any of the given sequences, whichever reacted first.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        [Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Amb", Justification = "In honor of McCarthy.")]
-        public static IObservable<TSource> Amb<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Amb(sources);
-        }
-
-        #endregion
-
-        #region + Buffer +
-
-        /// <summary>
-        /// Projects each element of an observable sequence into consecutive non-overlapping buffers.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence, and in the lists in the result sequence.</typeparam>
-        /// <typeparam name="TBufferClosing">The type of the elements in the sequences indicating buffer closing events.</typeparam>
-        /// <param name="source">Source sequence to produce buffers over.</param>
-        /// <param name="bufferClosingSelector">A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed.</param>
-        /// <returns>An observable sequence of buffers.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="bufferClosingSelector"/> is null.</exception>
-        public static IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(this IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (bufferClosingSelector == null)
-            {
-                throw new ArgumentNullException(nameof(bufferClosingSelector));
-            }
-
-            return s_impl.Buffer(source, bufferClosingSelector);
-        }
-
-        /// <summary>
-        /// Projects each element of an observable sequence into zero or more buffers.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence, and in the lists in the result sequence.</typeparam>
-        /// <typeparam name="TBufferOpening">The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events.</typeparam>
-        /// <typeparam name="TBufferClosing">The type of the elements in the sequences indicating buffer closing events.</typeparam>
-        /// <param name="source">Source sequence to produce buffers over.</param>
-        /// <param name="bufferOpenings">Observable sequence whose elements denote the creation of new buffers.</param>
-        /// <param name="bufferClosingSelector">A function invoked to define the closing of each produced buffer.</param>
-        /// <returns>An observable sequence of buffers.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="bufferOpenings"/> or <paramref name="bufferClosingSelector"/> is null.</exception>
-        public static IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(this IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (bufferOpenings == null)
-            {
-                throw new ArgumentNullException(nameof(bufferOpenings));
-            }
-
-            if (bufferClosingSelector == null)
-            {
-                throw new ArgumentNullException(nameof(bufferClosingSelector));
-            }
-
-            return s_impl.Buffer(source, bufferOpenings, bufferClosingSelector);
-        }
-
-        /// <summary>
-        /// Projects each element of an observable sequence into consecutive non-overlapping buffers.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence, and in the lists in the result sequence.</typeparam>
-        /// <typeparam name="TBufferBoundary">The type of the elements in the sequences indicating buffer boundary events.</typeparam>
-        /// <param name="source">Source sequence to produce buffers over.</param>
-        /// <param name="bufferBoundaries">Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker.</param>
-        /// <returns>An observable sequence of buffers.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="bufferBoundaries"/> is null.</exception>
-        public static IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(this IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (bufferBoundaries == null)
-            {
-                throw new ArgumentNullException(nameof(bufferBoundaries));
-            }
-
-            return s_impl.Buffer(source, bufferBoundaries);
-        }
-
-        #endregion
-
-        #region + Catch +
-
-        /// <summary>
-        /// Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence and sequences returned by the exception handler function.</typeparam>
-        /// <typeparam name="TException">The type of the exception to catch and handle. Needs to derive from <see cref="Exception"/>.</typeparam>
-        /// <param name="source">Source sequence.</param>
-        /// <param name="handler">Exception handler function, producing another observable sequence.</param>
-        /// <returns>An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="handler"/> is null.</exception>
-        public static IObservable<TSource> Catch<TSource, TException>(this IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (handler == null)
-            {
-                throw new ArgumentNullException(nameof(handler));
-            }
-
-            return s_impl.Catch(source, handler);
-        }
-
-        /// <summary>
-        /// Continues an observable sequence that is terminated by an exception with the next observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence and handler sequence.</typeparam>
-        /// <param name="first">First observable sequence whose exception (if any) is caught.</param>
-        /// <param name="second">Second observable sequence used to produce results when an error occurred in the first sequence.</param>
-        /// <returns>An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        public static IObservable<TSource> Catch<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.Catch(first, second);
-        }
-
-        /// <summary>
-        /// Continues an observable sequence that is terminated by an exception with the next observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source and handler sequences.</typeparam>
-        /// <param name="sources">Observable sequences to catch exceptions for.</param>
-        /// <returns>An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Catch<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Catch(sources);
-        }
-
-        /// <summary>
-        /// Continues an observable sequence that is terminated by an exception with the next observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source and handler sequences.</typeparam>
-        /// <param name="sources">Observable sequences to catch exceptions for.</param>
-        /// <returns>An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Catch<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Catch(sources);
-        }
-
-        #endregion
-
-        #region + CombineLatest +
-
-        /// <summary>
-        /// Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element.
-        /// </summary>
-        /// <typeparam name="TSource1">The type of the elements in the first source sequence.</typeparam>
-        /// <typeparam name="TSource2">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 observable source.</param>
-        /// <param name="second">Second observable source.</param>
-        /// <param name="resultSelector">Function to invoke whenever either of the sources produces an element.</param>
-        /// <returns>An observable sequence containing the result of combining elements of both sources using the specified result selector function.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
-        public static IObservable<TResult> CombineLatest<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IObservable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            if (resultSelector == null)
-            {
-                throw new ArgumentNullException(nameof(resultSelector));
-            }
-
-            return s_impl.CombineLatest(first, second, resultSelector);
-        }
-
-        /// <summary>
-        /// Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <typeparam name="TResult">The type of the elements in the result sequence, returned by the selector function.</typeparam>
-        /// <param name="sources">Observable sources.</param>
-        /// <param name="resultSelector">Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call.</param>
-        /// <returns>An observable sequence containing the result of combining elements of the sources using the specified result selector function.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="resultSelector"/> is null.</exception>
-        /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
-        public static IObservable<TResult> CombineLatest<TSource, TResult>(this IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            if (resultSelector == null)
-            {
-                throw new ArgumentNullException(nameof(resultSelector));
-            }
-
-            return s_impl.CombineLatest(sources, resultSelector);
-        }
-
-        /// <summary>
-        /// Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
-        /// <param name="sources">Observable sources.</param>
-        /// <returns>An observable sequence containing lists of the latest elements of the sources.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
-        public static IObservable<IList<TSource>> CombineLatest<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.CombineLatest(sources);
-        }
-
-        /// <summary>
-        /// Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
-        /// <param name="sources">Observable sources.</param>
-        /// <returns>An observable sequence containing lists of the latest elements of the sources.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <remarks>If a non-empty source completes, its very last value will be used for creating subsequent combinations until all sources terminate.</remarks>
-        public static IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.CombineLatest(sources);
-        }
-
-        #endregion
-
-        #region + Concat +
-
-        /// <summary>
-        /// Concatenates the second observable sequence to the first observable sequence upon successful termination of the first.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="first">First observable sequence.</param>
-        /// <param name="second">Second observable sequence.</param>
-        /// <returns>An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        public static IObservable<TSource> Concat<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.Concat(first, second);
-        }
-
-        /// <summary>
-        /// Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequences to concatenate.</param>
-        /// <returns>An observable sequence that contains the elements of each given sequence, in sequential order.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Concat(sources);
-        }
-
-        /// <summary>
-        /// Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequences to concatenate.</param>
-        /// <returns>An observable sequence that contains the elements of each given sequence, in sequential order.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Concat<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Concat(sources);
-        }
-
-        /// <summary>
-        /// Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequence of inner observable sequences.</param>
-        /// <returns>An observable sequence that contains the elements of each observed inner sequence, in sequential order.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Concat<TSource>(this IObservable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Concat(sources);
-        }
-
-        /// <summary>
-        /// Concatenates all task results, as long as the previous task terminated successfully.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the results produced by the tasks.</typeparam>
-        /// <param name="sources">Observable sequence of tasks.</param>
-        /// <returns>An observable sequence that contains the results of each task, in sequential order.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <remarks>If the tasks support cancellation, consider manual conversion of the tasks using <see cref="Observable.FromAsync{TSource}(Func{CancellationToken, Task{TSource}})"/>, followed by a concatenation operation using <see cref="Observable.Concat{TSource}(IObservable{IObservable{TSource}})"/>.</remarks>
-        public static IObservable<TSource> Concat<TSource>(this IObservable<Task<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Concat(sources);
-        }
-
-        #endregion
-
-        #region + Merge +
-
-        /// <summary>
-        /// Merges elements from all inner observable sequences into a single observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequence of inner observable sequences.</param>
-        /// <returns>The observable sequence that merges the elements of the inner sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IObservable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Merge(sources);
-        }
-
-        /// <summary>
-        /// Merges results from all source tasks into a single observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the results produced by the source tasks.</typeparam>
-        /// <param name="sources">Observable sequence of tasks.</param>
-        /// <returns>The observable sequence that merges the results of the source tasks.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <remarks>If the tasks support cancellation, consider manual conversion of the tasks using <see cref="Observable.FromAsync{TSource}(Func{CancellationToken, Task{TSource}})"/>, followed by a merge operation using <see cref="Observable.Merge{TSource}(IObservable{IObservable{TSource}})"/>.</remarks>
-        public static IObservable<TSource> Merge<TSource>(this IObservable<Task<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Merge(sources);
-        }
-
-        /// <summary>
-        /// Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequence of inner observable sequences.</param>
-        /// <param name="maxConcurrent">Maximum number of inner observable sequences being subscribed to concurrently.</param>
-        /// <returns>The observable sequence that merges the elements of the inner sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConcurrent"/> is less than or equal to zero.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IObservable<IObservable<TSource>> sources, int maxConcurrent)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            if (maxConcurrent <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(maxConcurrent));
-            }
-
-            return s_impl.Merge(sources, maxConcurrent);
-        }
-
-        /// <summary>
-        /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Enumerable sequence of observable sequences.</param>
-        /// <param name="maxConcurrent">Maximum number of observable sequences being subscribed to concurrently.</param>
-        /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConcurrent"/> is less than or equal to zero.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            if (maxConcurrent <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(maxConcurrent));
-            }
-
-            return s_impl.Merge(sources, maxConcurrent);
-        }
-
-        /// <summary>
-        /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Enumerable sequence of observable sequences.</param>
-        /// <param name="maxConcurrent">Maximum number of observable sequences being subscribed to concurrently.</param>
-        /// <param name="scheduler">Scheduler to run the enumeration of the sequence of sources on.</param>
-        /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="scheduler"/> is null.</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConcurrent"/> is less than or equal to zero.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            if (maxConcurrent <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(maxConcurrent));
-            }
-
-            if (scheduler == null)
-            {
-                throw new ArgumentNullException(nameof(scheduler));
-            }
-
-            return s_impl.Merge(sources, maxConcurrent, scheduler);
-        }
-
-        /// <summary>
-        /// Merges elements from two observable sequences into a single observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="first">First observable sequence.</param>
-        /// <param name="second">Second observable sequence.</param>
-        /// <returns>The observable sequence that merges the elements of the given sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.Merge(first, second);
-        }
-
-        /// <summary>
-        /// Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="first">First observable sequence.</param>
-        /// <param name="second">Second observable sequence.</param>
-        /// <param name="scheduler">Scheduler used to introduce concurrency for making subscriptions to the given sequences.</param>
-        /// <returns>The observable sequence that merges the elements of the given sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="scheduler"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            if (scheduler == null)
-            {
-                throw new ArgumentNullException(nameof(scheduler));
-            }
-
-            return s_impl.Merge(first, second, scheduler);
-        }
-
-        /// <summary>
-        /// Merges elements from all of the specified observable sequences into a single observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequences.</param>
-        /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Merge(sources);
-        }
-
-        /// <summary>
-        /// Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequences.</param>
-        /// <param name="scheduler">Scheduler to run the enumeration of the sequence of sources on.</param>
-        /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> or <paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources)
-        {
-            if (scheduler == null)
-            {
-                throw new ArgumentNullException(nameof(scheduler));
-            }
-
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Merge(scheduler, sources);
-        }
-
-        /// <summary>
-        /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Enumerable sequence of observable sequences.</param>
-        /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Merge(sources);
-        }
-
-        /// <summary>
-        /// Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Enumerable sequence of observable sequences.</param>
-        /// <param name="scheduler">Scheduler to run the enumeration of the sequence of sources on.</param>
-        /// <returns>The observable sequence that merges the elements of the observable sequences.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="scheduler"/> is null.</exception>
-        public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, IScheduler scheduler)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            if (scheduler == null)
-            {
-                throw new ArgumentNullException(nameof(scheduler));
-            }
-
-            return s_impl.Merge(sources, scheduler);
-        }
-
-        #endregion
-
-        #region + OnErrorResumeNext +
-
-        /// <summary>
-        /// Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="first">First observable sequence whose exception (if any) is caught.</param>
-        /// <param name="second">Second observable sequence used to produce results after the first sequence terminates.</param>
-        /// <returns>An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        public static IObservable<TSource> OnErrorResumeNext<TSource>(this IObservable<TSource> first, IObservable<TSource> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.OnErrorResumeNext(first, second);
-        }
-
-        /// <summary>
-        /// Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequences to concatenate.</param>
-        /// <returns>An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> OnErrorResumeNext<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.OnErrorResumeNext(sources);
-        }
-
-        /// <summary>
-        /// Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequences to concatenate.</param>
-        /// <returns>An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> OnErrorResumeNext<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.OnErrorResumeNext(sources);
-        }
-
-        #endregion
-
-        #region + SkipUntil +
-
-        /// <summary>
-        /// Returns the elements from the source observable sequence only after the other observable sequence produces an element.
-        /// Starting from Rx.NET 4.0, this will subscribe to <paramref name="other"/> before subscribing to <paramref name="source" />
-        /// so in case <paramref name="other" /> emits an element right away, elements from <paramref name="source" /> are not missed.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <typeparam name="TOther">The type of the elements in the other sequence that indicates the end of skip behavior.</typeparam>
-        /// <param name="source">Source sequence to propagate elements for.</param>
-        /// <param name="other">Observable sequence that triggers propagation of elements of the source sequence.</param>
-        /// <returns>An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="other"/> is null.</exception>
-        public static IObservable<TSource> SkipUntil<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (other == null)
-            {
-                throw new ArgumentNullException(nameof(other));
-            }
-
-            return s_impl.SkipUntil(source, other);
-        }
-
-        #endregion
-
-        #region + Switch +
-
-        /// <summary>
-        /// Transforms an observable sequence of observable sequences into an observable sequence 
-        /// producing values only from the most recent observable sequence.
-        /// Each time a new inner observable sequence is received, unsubscribe from the 
-        /// previous inner observable sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <param name="sources">Observable sequence of inner observable sequences.</param>
-        /// <returns>The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<TSource> Switch<TSource>(this IObservable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Switch(sources);
-        }
-
-        /// <summary>
-        /// Transforms an observable sequence of tasks into an observable sequence 
-        /// producing values only from the most recent observable sequence.
-        /// Each time a new task is received, the previous task's result is ignored.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the results produced by the source tasks.</typeparam>
-        /// <param name="sources">Observable sequence of tasks.</param>
-        /// <returns>The observable sequence that at any point in time produces the result of the most recent task that has been received.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        /// <remarks>If the tasks support cancellation, consider manual conversion of the tasks using <see cref="Observable.FromAsync{TSource}(Func{CancellationToken, Task{TSource}})"/>, followed by a switch operation using <see cref="Observable.Switch{TSource}(IObservable{IObservable{TSource}})"/>.</remarks>
-        public static IObservable<TSource> Switch<TSource>(this IObservable<Task<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Switch(sources);
-        }
-
-        #endregion
-
-        #region + TakeUntil +
-
-        /// <summary>
-        /// Returns the elements from the source observable sequence until the other observable sequence produces an element.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-        /// <typeparam name="TOther">The type of the elements in the other sequence that indicates the end of take behavior.</typeparam>
-        /// <param name="source">Source sequence to propagate elements for.</param>
-        /// <param name="other">Observable sequence that terminates propagation of elements of the source sequence.</param>
-        /// <returns>An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="other"/> is null.</exception>
-        public static IObservable<TSource> TakeUntil<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (other == null)
-            {
-                throw new ArgumentNullException(nameof(other));
-            }
-
-            return s_impl.TakeUntil(source, other);
-        }
-
-        /// <summary>
-        /// Relays elements from the source observable sequence and calls the predicate after an
-        /// emission to check if the sequence should stop after that specific item.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source and result sequences.</typeparam>
-        /// <param name="source">The source sequence to relay elements of.</param>
-        /// <param name="stopPredicate">Called after each upstream item has been emitted with
-        /// that upstream item and should return <code>true</code> to indicate the sequence should
-        /// complete.</param>
-        /// <returns>The observable sequence with the source elements until the stop predicate returns true.</returns>
-        /// <example>
-        /// The following sequence will stop after the value 5 has been encountered:
-        /// <code>
-        /// Observable.Range(1, 10)
-        ///     .TakeUntil(item =&gt; item == 5)
-        ///     .Subscribe(Console.WriteLine);
-        /// </code>
-        /// </example>
-        /// <exception cref="ArgumentException">If <typeparamref name="TSource"/> or <paramref name="stopPredicate"/> is <code>null</code>.</exception>
-        public static IObservable<TSource> TakeUntil<TSource>(this IObservable<TSource> source, Func<TSource, bool> stopPredicate)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (stopPredicate == null)
-            {
-                throw new ArgumentNullException(nameof(stopPredicate));
-            }
-
-            return s_impl.TakeUntil(source, stopPredicate);
-        }
-
-        #endregion
-
-        #region + Window +
-
-        /// <summary>
-        /// Projects each element of an observable sequence into consecutive non-overlapping windows.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence, and in the windows in the result sequence.</typeparam>
-        /// <typeparam name="TWindowClosing">The type of the elements in the sequences indicating window closing events.</typeparam>
-        /// <param name="source">Source sequence to produce windows over.</param>
-        /// <param name="windowClosingSelector">A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed.</param>
-        /// <returns>An observable sequence of windows.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="windowClosingSelector"/> is null.</exception>
-        public static IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(this IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (windowClosingSelector == null)
-            {
-                throw new ArgumentNullException(nameof(windowClosingSelector));
-            }
-
-            return s_impl.Window(source, windowClosingSelector);
-        }
-
-        /// <summary>
-        /// Projects each element of an observable sequence into zero or more windows.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence, and in the windows in the result sequence.</typeparam>
-        /// <typeparam name="TWindowOpening">The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events.</typeparam>
-        /// <typeparam name="TWindowClosing">The type of the elements in the sequences indicating window closing events.</typeparam>
-        /// <param name="source">Source sequence to produce windows over.</param>
-        /// <param name="windowOpenings">Observable sequence whose elements denote the creation of new windows.</param>
-        /// <param name="windowClosingSelector">A function invoked to define the closing of each produced window.</param>
-        /// <returns>An observable sequence of windows.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="windowOpenings"/> or <paramref name="windowClosingSelector"/> is null.</exception>
-        public static IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(this IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (windowOpenings == null)
-            {
-                throw new ArgumentNullException(nameof(windowOpenings));
-            }
-
-            if (windowClosingSelector == null)
-            {
-                throw new ArgumentNullException(nameof(windowClosingSelector));
-            }
-
-            return s_impl.Window(source, windowOpenings, windowClosingSelector);
-        }
-
-        /// <summary>
-        /// Projects each element of an observable sequence into consecutive non-overlapping windows.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequence, and in the windows in the result sequence.</typeparam>
-        /// <typeparam name="TWindowBoundary">The type of the elements in the sequences indicating window boundary events.</typeparam>
-        /// <param name="source">Source sequence to produce windows over.</param>
-        /// <param name="windowBoundaries">Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker.</param>
-        /// <returns>An observable sequence of windows.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="windowBoundaries"/> is null.</exception>
-        public static IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(this IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (windowBoundaries == null)
-            {
-                throw new ArgumentNullException(nameof(windowBoundaries));
-            }
-
-            return s_impl.Window(source, windowBoundaries);
-        }
-
-        #endregion
-
-        #region + WithLatestFrom +
-
-        /// <summary>
-        /// Merges two observable sequences into one observable sequence by combining each element from the first source with the latest element from the second source, if any.
-        /// Starting from Rx.NET 4.0, this will subscribe to <paramref name="second"/> before subscribing to <paramref name="first" /> to have a latest element readily available
-        /// in case <paramref name="first" /> emits an element right away.
-        /// </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 observable source.</param>
-        /// <param name="second">Second observable source.</param>
-        /// <param name="resultSelector">Function to invoke for each element from the first source combined with the latest element from the second source, if any.</param>
-        /// <returns>An observable sequence containing the result of combining each element of the first source with the latest element from the second source, if any, using the specified result selector function.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="resultSelector"/> is null.</exception>
-        public static IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            if (resultSelector == null)
-            {
-                throw new ArgumentNullException(nameof(resultSelector));
-            }
-
-            return s_impl.WithLatestFrom(first, second, resultSelector);
-        }
-
-        #endregion
-
-        #region + Zip +
-
-        /// <summary>
-        /// Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion.
-        /// </summary>
-        /// <typeparam name="TSource1">The type of the elements in the first source sequence.</typeparam>
-        /// <typeparam name="TSource2">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 observable source.</param>
-        /// <param name="second">Second observable source.</param>
-        /// <param name="resultSelector">Function to invoke for each consecutive pair of elements from the first and second source.</param>
-        /// <returns>An observable 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="resultSelector"/> is null.</exception>
-        public static IObservable<TResult> Zip<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IObservable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            if (resultSelector == null)
-            {
-                throw new ArgumentNullException(nameof(resultSelector));
-            }
-
-            return s_impl.Zip(first, second, resultSelector);
-        }
-
-        /// <summary>
-        /// Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
-        /// <typeparam name="TResult">The type of the elements in the result sequence, returned by the selector function.</typeparam>
-        /// <param name="sources">Observable sources.</param>
-        /// <param name="resultSelector">Function to invoke for each series of elements at corresponding indexes in the sources.</param>
-        /// <returns>An observable sequence containing the result of combining elements of the sources using the specified result selector function.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="resultSelector"/> is null.</exception>
-        public static IObservable<TResult> Zip<TSource, TResult>(this IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            if (resultSelector == null)
-            {
-                throw new ArgumentNullException(nameof(resultSelector));
-            }
-
-            return s_impl.Zip(sources, resultSelector);
-        }
-
-        /// <summary>
-        /// Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
-        /// <param name="sources">Observable sources.</param>
-        /// <returns>An observable sequence containing lists of elements at corresponding indexes.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<IList<TSource>> Zip<TSource>(this IEnumerable<IObservable<TSource>> sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Zip(sources);
-        }
-
-        /// <summary>
-        /// Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
-        /// <param name="sources">Observable sources.</param>
-        /// <returns>An observable sequence containing lists of elements at corresponding indexes.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
-        public static IObservable<IList<TSource>> Zip<TSource>(params IObservable<TSource>[] sources)
-        {
-            if (sources == null)
-            {
-                throw new ArgumentNullException(nameof(sources));
-            }
-
-            return s_impl.Zip(sources);
-        }
-
-        /// <summary>
-        /// Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function.
-        /// </summary>
-        /// <typeparam name="TSource1">The type of the elements in the first observable source sequence.</typeparam>
-        /// <typeparam name="TSource2">The type of the elements in the second enumerable 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 observable source.</param>
-        /// <param name="second">Second enumerable source.</param>
-        /// <param name="resultSelector">Function to invoke for each consecutive pair of elements from the first and second source.</param>
-        /// <returns>An observable 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="resultSelector"/> is null.</exception>
-        public static IObservable<TResult> Zip<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IEnumerable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            if (resultSelector == null)
-            {
-                throw new ArgumentNullException(nameof(resultSelector));
-            }
-
-            return s_impl.Zip(first, second, resultSelector);
-        }
-
-        #endregion
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (other == null)
+        {
+            throw new ArgumentNullException(nameof(other));
+        }
+
+        return s_impl.SkipUntil(source, other);
     }
 
+    #endregion
+
+    #region + Switch +
+
+    /// <summary>
+    /// Transforms an observable sequence of observable sequences into an observable sequence 
+    /// producing values only from the most recent observable sequence.
+    /// Each time a new inner observable sequence is received, unsubscribe from the 
+    /// previous inner observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <param name="sources">Observable sequence of inner observable sequences.</param>
+    /// <returns>The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<TSource> Switch<TSource>(this IObservable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Switch(sources);
+    }
+
+    /// <summary>
+    /// Transforms an observable sequence of tasks into an observable sequence 
+    /// producing values only from the most recent observable sequence.
+    /// Each time a new task is received, the previous task's result is ignored.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the results produced by the source tasks.</typeparam>
+    /// <param name="sources">Observable sequence of tasks.</param>
+    /// <returns>The observable sequence that at any point in time produces the result of the most recent task that has been received.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    /// <remarks>If the tasks support cancellation, consider manual conversion of the tasks using <see cref="Observable.FromAsync{TSource}(Func{CancellationToken, Task{TSource}})"/>, followed by a switch operation using <see cref="Observable.Switch{TSource}(IObservable{IObservable{TSource}})"/>.</remarks>
+    public static IObservable<TSource> Switch<TSource>(this IObservable<Task<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Switch(sources);
+    }
+
+    #endregion
+
+    #region + TakeUntil +
+
+    /// <summary>
+    /// Returns the elements from the source observable sequence until the other observable sequence produces an element.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+    /// <typeparam name="TOther">The type of the elements in the other sequence that indicates the end of take behavior.</typeparam>
+    /// <param name="source">Source sequence to propagate elements for.</param>
+    /// <param name="other">Observable sequence that terminates propagation of elements of the source sequence.</param>
+    /// <returns>An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="other"/> is null.</exception>
+    public static IObservable<TSource> TakeUntil<TSource, TOther>(this IObservable<TSource> source, IObservable<TOther> other)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (other == null)
+        {
+            throw new ArgumentNullException(nameof(other));
+        }
+
+        return s_impl.TakeUntil(source, other);
+    }
+
+    /// <summary>
+    /// Relays elements from the source observable sequence and calls the predicate after an
+    /// emission to check if the sequence should stop after that specific item.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source and result sequences.</typeparam>
+    /// <param name="source">The source sequence to relay elements of.</param>
+    /// <param name="stopPredicate">Called after each upstream item has been emitted with
+    /// that upstream item and should return <code>true</code> to indicate the sequence should
+    /// complete.</param>
+    /// <returns>The observable sequence with the source elements until the stop predicate returns true.</returns>
+    /// <example>
+    /// The following sequence will stop after the value 5 has been encountered:
+    /// <code>
+    /// Observable.Range(1, 10)
+    ///     .TakeUntil(item =&gt; item == 5)
+    ///     .Subscribe(Console.WriteLine);
+    /// </code>
+    /// </example>
+    /// <exception cref="ArgumentException">If <typeparamref name="TSource"/> or <paramref name="stopPredicate"/> is <code>null</code>.</exception>
+    public static IObservable<TSource> TakeUntil<TSource>(this IObservable<TSource> source, Func<TSource, bool> stopPredicate)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (stopPredicate == null)
+        {
+            throw new ArgumentNullException(nameof(stopPredicate));
+        }
+
+        return s_impl.TakeUntil(source, stopPredicate);
+    }
+
+    /// <summary>
+    /// Relays elements from the source observable sequence until the provided <paramref name="cancellationToken"/> is canceled.
+    /// Completes immediately if the provided <paramref name="cancellationToken"/> is already canceled upon subscription.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source and result sequences.</typeparam>
+    /// <param name="source">The source sequence to relay elements of.</param>
+    /// <param name="cancellationToken">The cancellation token to complete the target observable sequence on.</param>
+    /// <returns>The observable sequence with the source elements until the provided <paramref name="cancellationToken"/> is canceled.</returns>
+    /// <exception cref="ArgumentException">If <typeparamref name="TSource"/> is <code>null</code>.</exception>
+    public static IObservable<TSource> TakeUntil<TSource>(this IObservable<TSource> source, CancellationToken cancellationToken)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        return s_impl.TakeUntil(source, cancellationToken);
+    }
+
+    #endregion
+
+    #region + Window +
+
+    /// <summary>
+    /// Projects each element of an observable sequence into consecutive non-overlapping windows.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence, and in the windows in the result sequence.</typeparam>
+    /// <typeparam name="TWindowClosing">The type of the elements in the sequences indicating window closing events.</typeparam>
+    /// <param name="source">Source sequence to produce windows over.</param>
+    /// <param name="windowClosingSelector">A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed.</param>
+    /// <returns>An observable sequence of windows.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="windowClosingSelector"/> is null.</exception>
+    public static IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(this IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (windowClosingSelector == null)
+        {
+            throw new ArgumentNullException(nameof(windowClosingSelector));
+        }
+
+        return s_impl.Window(source, windowClosingSelector);
+    }
+
+    /// <summary>
+    /// Projects each element of an observable sequence into zero or more windows.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence, and in the windows in the result sequence.</typeparam>
+    /// <typeparam name="TWindowOpening">The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events.</typeparam>
+    /// <typeparam name="TWindowClosing">The type of the elements in the sequences indicating window closing events.</typeparam>
+    /// <param name="source">Source sequence to produce windows over.</param>
+    /// <param name="windowOpenings">Observable sequence whose elements denote the creation of new windows.</param>
+    /// <param name="windowClosingSelector">A function invoked to define the closing of each produced window.</param>
+    /// <returns>An observable sequence of windows.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="windowOpenings"/> or <paramref name="windowClosingSelector"/> is null.</exception>
+    public static IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(this IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (windowOpenings == null)
+        {
+            throw new ArgumentNullException(nameof(windowOpenings));
+        }
+
+        if (windowClosingSelector == null)
+        {
+            throw new ArgumentNullException(nameof(windowClosingSelector));
+        }
+
+        return s_impl.Window(source, windowOpenings, windowClosingSelector);
+    }
+
+    /// <summary>
+    /// Projects each element of an observable sequence into consecutive non-overlapping windows.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence, and in the windows in the result sequence.</typeparam>
+    /// <typeparam name="TWindowBoundary">The type of the elements in the sequences indicating window boundary events.</typeparam>
+    /// <param name="source">Source sequence to produce windows over.</param>
+    /// <param name="windowBoundaries">Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker.</param>
+    /// <returns>An observable sequence of windows.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="windowBoundaries"/> is null.</exception>
+    public static IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(this IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (windowBoundaries == null)
+        {
+            throw new ArgumentNullException(nameof(windowBoundaries));
+        }
+
+        return s_impl.Window(source, windowBoundaries);
+    }
+
+    #endregion
+
+    #region + WithLatestFrom +
+
+    /// <summary>
+    /// Merges two observable sequences into one observable sequence by combining each element from the first source with the latest element from the second source, if any.
+    /// Starting from Rx.NET 4.0, this will subscribe to <paramref name="second"/> before subscribing to <paramref name="first" /> to have a latest element readily available
+    /// in case <paramref name="first" /> emits an element right away.
+    /// </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 observable source.</param>
+    /// <param name="second">Second observable source.</param>
+    /// <param name="resultSelector">Function to invoke for each element from the first source combined with the latest element from the second source, if any.</param>
+    /// <returns>An observable sequence containing the result of combining each element of the first source with the latest element from the second source, if any, using the specified result selector function.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> or <paramref name="resultSelector"/> is null.</exception>
+    public static IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        if (resultSelector == null)
+        {
+            throw new ArgumentNullException(nameof(resultSelector));
+        }
+
+        return s_impl.WithLatestFrom(first, second, resultSelector);
+    }
+
+    #endregion
+
+    #region + Zip +
+
+    /// <summary>
+    /// Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion.
+    /// </summary>
+    /// <typeparam name="TSource1">The type of the elements in the first source sequence.</typeparam>
+    /// <typeparam name="TSource2">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 observable source.</param>
+    /// <param name="second">Second observable source.</param>
+    /// <param name="resultSelector">Function to invoke for each consecutive pair of elements from the first and second source.</param>
+    /// <returns>An observable 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="resultSelector"/> is null.</exception>
+    public static IObservable<TResult> Zip<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IObservable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        if (resultSelector == null)
+        {
+            throw new ArgumentNullException(nameof(resultSelector));
+        }
+
+        return s_impl.Zip(first, second, resultSelector);
+    }
+
+    /// <summary>
+    /// Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
+    /// <typeparam name="TResult">The type of the elements in the result sequence, returned by the selector function.</typeparam>
+    /// <param name="sources">Observable sources.</param>
+    /// <param name="resultSelector">Function to invoke for each series of elements at corresponding indexes in the sources.</param>
+    /// <returns>An observable sequence containing the result of combining elements of the sources using the specified result selector function.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> or <paramref name="resultSelector"/> is null.</exception>
+    public static IObservable<TResult> Zip<TSource, TResult>(this IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        if (resultSelector == null)
+        {
+            throw new ArgumentNullException(nameof(resultSelector));
+        }
+
+        return s_impl.Zip(sources, resultSelector);
+    }
+
+    /// <summary>
+    /// Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
+    /// <param name="sources">Observable sources.</param>
+    /// <returns>An observable sequence containing lists of elements at corresponding indexes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<IList<TSource>> Zip<TSource>(this IEnumerable<IObservable<TSource>> sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Zip(sources);
+    }
+
+    /// <summary>
+    /// Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequences, and in the lists in the result sequence.</typeparam>
+    /// <param name="sources">Observable sources.</param>
+    /// <returns>An observable sequence containing lists of elements at corresponding indexes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is null.</exception>
+    public static IObservable<IList<TSource>> Zip<TSource>(params IObservable<TSource>[] sources)
+    {
+        if (sources == null)
+        {
+            throw new ArgumentNullException(nameof(sources));
+        }
+
+        return s_impl.Zip(sources);
+    }
+
+    /// <summary>
+    /// Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function.
+    /// </summary>
+    /// <typeparam name="TSource1">The type of the elements in the first observable source sequence.</typeparam>
+    /// <typeparam name="TSource2">The type of the elements in the second enumerable 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 observable source.</param>
+    /// <param name="second">Second enumerable source.</param>
+    /// <param name="resultSelector">Function to invoke for each consecutive pair of elements from the first and second source.</param>
+    /// <returns>An observable 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="resultSelector"/> is null.</exception>
+    public static IObservable<TResult> Zip<TSource1, TSource2, TResult>(this IObservable<TSource1> first, IEnumerable<TSource2> second, Func<TSource1, TSource2, TResult> resultSelector)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        if (resultSelector == null)
+        {
+            throw new ArgumentNullException(nameof(resultSelector));
+        }
+
+        return s_impl.Zip(first, second, resultSelector);
+    }
+
+    #endregion
+}
+
 #pragma warning disable CA1711 // (Don't use Ex suffix.) This has been a public type for many years, so we can't rename it now.
-    public static partial class ObservableEx
+public static partial class ObservableEx
 #pragma warning restore CA1711
+{
+    /// <summary>
+    /// Merges two observable sequences into one observable sequence by combining each element from the first source with the latest element from the second source, if any.
+    /// </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>
+    /// <param name="first">First observable source.</param>
+    /// <param name="second">Second observable source.</param>
+    /// <returns>An observable sequence containing the result of combining each element of the first source with the latest element from the second source, if any, as a tuple value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    public static IObservable<(TFirst First, TSecond Second)> WithLatestFrom<TFirst, TSecond>(this IObservable<TFirst> first, IObservable<TSecond> second)
+    {
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
+        }
+
+        return s_impl.WithLatestFrom(first, second);
+    }
+
+    /// <summary>
+    /// Merges an observable sequence and an enumerable sequence into one observable sequence of tuple values.
+    /// </summary>
+    /// <typeparam name="TFirst">The type of the elements in the first observable source sequence.</typeparam>
+    /// <typeparam name="TSecond">The type of the elements in the second enumerable source sequence.</typeparam>
+    /// <param name="first">First observable source.</param>
+    /// <param name="second">Second enumerable source.</param>
+    /// <returns>An observable sequence containing the result of pairwise combining the elements of the first and second source as a tuple value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
+    public static IObservable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IObservable<TFirst> first, IEnumerable<TSecond> second)
     {
-        /// <summary>
-        /// Merges two observable sequences into one observable sequence by combining each element from the first source with the latest element from the second source, if any.
-        /// </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>
-        /// <param name="first">First observable source.</param>
-        /// <param name="second">Second observable source.</param>
-        /// <returns>An observable sequence containing the result of combining each element of the first source with the latest element from the second source, if any, as a tuple value.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        public static IObservable<(TFirst First, TSecond Second)> WithLatestFrom<TFirst, TSecond>(this IObservable<TFirst> first, IObservable<TSecond> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.WithLatestFrom(first, second);
-        }
-
-        /// <summary>
-        /// Merges an observable sequence and an enumerable sequence into one observable sequence of tuple values.
-        /// </summary>
-        /// <typeparam name="TFirst">The type of the elements in the first observable source sequence.</typeparam>
-        /// <typeparam name="TSecond">The type of the elements in the second enumerable source sequence.</typeparam>
-        /// <param name="first">First observable source.</param>
-        /// <param name="second">Second enumerable source.</param>
-        /// <returns>An observable sequence containing the result of pairwise combining the elements of the first and second source as a tuple value.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
-        public static IObservable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IObservable<TFirst> first, IEnumerable<TSecond> second)
-        {
-            if (first == null)
-            {
-                throw new ArgumentNullException(nameof(first));
-            }
-
-            if (second == null)
-            {
-                throw new ArgumentNullException(nameof(second));
-            }
-
-            return s_impl.Zip(first, second);
+        if (first == null)
+        {
+            throw new ArgumentNullException(nameof(first));
+        }
+
+        if (second == null)
+        {
+            throw new ArgumentNullException(nameof(second));
         }
+
+        return s_impl.Zip(first, second);
     }
 }
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeUntilCancellationToken.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeUntilCancellationToken.cs
new file mode 100644
index 000000000..ff45cadc4
--- /dev/null
+++ b/Rx.NET/Source/src/System.Reactive/Linq/Observable/TakeUntilCancellationToken.cs
@@ -0,0 +1,76 @@
+// 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.
+
+namespace System.Reactive.Linq.ObservableImpl;
+using System;
+using System.Reactive.Disposables;
+using System.Threading;
+
+/// <summary>
+/// Relays items to the downstream until the CancellationToken is cancled.
+/// </summary>
+/// <typeparam name="TSource">The element type of the sequence</typeparam>
+internal sealed class TakeUntilCancellationToken<TSource> :
+    Producer<TSource, TakeUntilCancellationToken<TSource>._>
+{
+    private readonly IObservable<TSource> _source;
+    private readonly CancellationToken _token;
+
+    public TakeUntilCancellationToken(IObservable<TSource> source, CancellationToken token)
+    {
+        _source = source;
+        _token = token;
+    }
+
+    protected override _ CreateSink(IObserver<TSource> observer) => new(observer);
+
+    protected override void Run(_ sink) => sink.Run(this);
+
+    internal sealed class _ : IdentitySink<TSource>
+    {
+        private SingleAssignmentDisposableValue _cancellationTokenRegistration;
+        private int _wip;
+        private Exception? _error;
+
+        public _(IObserver<TSource> observer) : base(observer)
+        {
+        }
+
+        public void Run(TakeUntilCancellationToken<TSource> parent)
+        {
+            if (parent._token.IsCancellationRequested)
+            {
+                OnCompleted();
+                return;
+            }
+
+            _cancellationTokenRegistration.Disposable = parent._token.Register(OnCompleted);
+            Run(parent._source);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _cancellationTokenRegistration.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        public override void OnNext(TSource value)
+        {
+            HalfSerializer.ForwardOnNext(this, value, ref _wip, ref _error);
+        }
+
+        public override void OnError(Exception error)
+        {
+            HalfSerializer.ForwardOnError(this, error, ref _wip, ref _error);
+        }
+
+        public override void OnCompleted()
+        {
+            HalfSerializer.ForwardOnCompleted(this, ref _wip, ref _error);
+        }
+    }
+}
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.cs
index 4a9d1b6d1..4f8289fa1 100644
--- a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.cs
+++ b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.cs
@@ -2,348 +2,352 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
+namespace System.Reactive.Linq;
+
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Concurrency;
+using System.Reactive.Linq.ObservableImpl;
 using System.Reactive.Threading.Tasks;
+using System.Threading;
 using System.Threading.Tasks;
 
-namespace System.Reactive.Linq
+internal partial class QueryLanguage
 {
-    using ObservableImpl;
+    #region + Amb +
+
+    public virtual IObservable<TSource> Amb<TSource>(IObservable<TSource> first, IObservable<TSource> second)
+    {
+        return new Amb<TSource>(first, second);
+    }
+
+    public virtual IObservable<TSource> Amb<TSource>(params IObservable<TSource>[] sources)
+    {
+        return new AmbManyArray<TSource>(sources);
+    }
+
+    public virtual IObservable<TSource> Amb<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return new AmbManyEnumerable<TSource>(sources);
+    }
+
+    #endregion
+
+    #region + Buffer +
+
+    public virtual IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector)
+    {
+        return new Buffer<TSource, TBufferClosing>.Selector(source, bufferClosingSelector);
+    }
+
+    public virtual IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector)
+    {
+        return source.Window(bufferOpenings, bufferClosingSelector).SelectMany(ToList);
+    }
+
+    public virtual IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries)
+    {
+        return new Buffer<TSource, TBufferBoundary>.Boundaries(source, bufferBoundaries);
+    }
+
+    #endregion
+
+    #region + Catch +
+
+    public virtual IObservable<TSource> Catch<TSource, TException>(IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception
+    {
+        return new Catch<TSource, TException>(source, handler);
+    }
+
+    public virtual IObservable<TSource> Catch<TSource>(IObservable<TSource> first, IObservable<TSource> second)
+    {
+        return Catch_(new[] { first, second });
+    }
+
+    public virtual IObservable<TSource> Catch<TSource>(params IObservable<TSource>[] sources)
+    {
+        return Catch_(sources);
+    }
+
+    public virtual IObservable<TSource> Catch<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return Catch_(sources);
+    }
+
+    private static IObservable<TSource> Catch_<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return new Catch<TSource>(sources);
+    }
+
+    #endregion
+
+    #region + CombineLatest +
+
+    public virtual IObservable<TResult> CombineLatest<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
+    {
+        return new CombineLatest<TFirst, TSecond, TResult>(first, second, resultSelector);
+    }
+
+    public virtual IObservable<TResult> CombineLatest<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
+    {
+        return CombineLatest_(sources, resultSelector);
+    }
+
+    public virtual IObservable<IList<TSource>> CombineLatest<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return CombineLatest_(sources, res => res.ToList());
+    }
+
+    public virtual IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources)
+    {
+        return CombineLatest_(sources, res => res.ToList());
+    }
+
+    private static IObservable<TResult> CombineLatest_<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
+    {
+        return new CombineLatest<TSource, TResult>(sources, resultSelector);
+    }
+
+    #endregion
+
+    #region + Concat +
+
+    public virtual IObservable<TSource> Concat<TSource>(IObservable<TSource> first, IObservable<TSource> second)
+    {
+        return Concat_(new[] { first, second });
+    }
+
+    public virtual IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources)
+    {
+        return Concat_(sources);
+    }
+
+    public virtual IObservable<TSource> Concat<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return Concat_(sources);
+    }
+
+    private static IObservable<TSource> Concat_<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return new Concat<TSource>(sources);
+    }
+
+    public virtual IObservable<TSource> Concat<TSource>(IObservable<IObservable<TSource>> sources)
+    {
+        return Concat_(sources);
+    }
 
-    internal partial class QueryLanguage
+    public virtual IObservable<TSource> Concat<TSource>(IObservable<Task<TSource>> sources)
     {
-        #region + Amb +
+        return Concat_(Select(sources, TaskObservableExtensions.ToObservable));
+    }
 
-        public virtual IObservable<TSource> Amb<TSource>(IObservable<TSource> first, IObservable<TSource> second)
-        {
-            return new Amb<TSource>(first, second);
-        }
+    private static IObservable<TSource> Concat_<TSource>(IObservable<IObservable<TSource>> sources)
+    {
+        return new ConcatMany<TSource>(sources);
+    }
 
-        public virtual IObservable<TSource> Amb<TSource>(params IObservable<TSource>[] sources)
-        {
-            return new AmbManyArray<TSource>(sources);
-        }
+    #endregion
 
-        public virtual IObservable<TSource> Amb<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return new AmbManyEnumerable<TSource>(sources);
-        }
+    #region + Merge +
 
-        #endregion
+    public virtual IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources)
+    {
+        return Merge_(sources);
+    }
 
-        #region + Buffer +
+    public virtual IObservable<TSource> Merge<TSource>(IObservable<Task<TSource>> sources)
+    {
+        return new Merge<TSource>.Tasks(sources);
+    }
+
+    public virtual IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources, int maxConcurrent)
+    {
+        return Merge_(sources, maxConcurrent);
+    }
 
-        public virtual IObservable<IList<TSource>> Buffer<TSource, TBufferClosing>(IObservable<TSource> source, Func<IObservable<TBufferClosing>> bufferClosingSelector)
-        {
-            return new Buffer<TSource, TBufferClosing>.Selector(source, bufferClosingSelector);
-        }
+    public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent)
+    {
+        return Merge_(sources.ToObservable(SchedulerDefaults.ConstantTimeOperations), maxConcurrent);
+    }
 
-        public virtual IObservable<IList<TSource>> Buffer<TSource, TBufferOpening, TBufferClosing>(IObservable<TSource> source, IObservable<TBufferOpening> bufferOpenings, Func<TBufferOpening, IObservable<TBufferClosing>> bufferClosingSelector)
-        {
-            return source.Window(bufferOpenings, bufferClosingSelector).SelectMany(ToList);
-        }
+    public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler)
+    {
+        return Merge_(sources.ToObservable(scheduler), maxConcurrent);
+    }
 
-        public virtual IObservable<IList<TSource>> Buffer<TSource, TBufferBoundary>(IObservable<TSource> source, IObservable<TBufferBoundary> bufferBoundaries)
-        {
-            return new Buffer<TSource, TBufferBoundary>.Boundaries(source, bufferBoundaries);
-        }
+    public virtual IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second)
+    {
+        return Merge_(new[] { first, second }.ToObservable(SchedulerDefaults.ConstantTimeOperations));
+    }
 
-        #endregion
+    public virtual IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler)
+    {
+        return Merge_(new[] { first, second }.ToObservable(scheduler));
+    }
 
-        #region + Catch +
+    public virtual IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources)
+    {
+        return Merge_(sources.ToObservable(SchedulerDefaults.ConstantTimeOperations));
+    }
 
-        public virtual IObservable<TSource> Catch<TSource, TException>(IObservable<TSource> source, Func<TException, IObservable<TSource>> handler) where TException : Exception
-        {
-            return new Catch<TSource, TException>(source, handler);
-        }
+    public virtual IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources)
+    {
+        return Merge_(sources.ToObservable(scheduler));
+    }
 
-        public virtual IObservable<TSource> Catch<TSource>(IObservable<TSource> first, IObservable<TSource> second)
-        {
-            return Catch_(new[] { first, second });
-        }
+    public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return Merge_(sources.ToObservable(SchedulerDefaults.ConstantTimeOperations));
+    }
 
-        public virtual IObservable<TSource> Catch<TSource>(params IObservable<TSource>[] sources)
-        {
-            return Catch_(sources);
-        }
+    public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, IScheduler scheduler)
+    {
+        return Merge_(sources.ToObservable(scheduler));
+    }
 
-        public virtual IObservable<TSource> Catch<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return Catch_(sources);
-        }
-
-        private static IObservable<TSource> Catch_<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return new Catch<TSource>(sources);
-        }
-
-        #endregion
+    private static IObservable<TSource> Merge_<TSource>(IObservable<IObservable<TSource>> sources)
+    {
+        return new Merge<TSource>.Observables(sources);
+    }
 
-        #region + CombineLatest +
-
-        public virtual IObservable<TResult> CombineLatest<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            return new CombineLatest<TFirst, TSecond, TResult>(first, second, resultSelector);
-        }
-
-        public virtual IObservable<TResult> CombineLatest<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
-        {
-            return CombineLatest_(sources, resultSelector);
-        }
-
-        public virtual IObservable<IList<TSource>> CombineLatest<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return CombineLatest_(sources, res => res.ToList());
-        }
-
-        public virtual IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources)
-        {
-            return CombineLatest_(sources, res => res.ToList());
-        }
-
-        private static IObservable<TResult> CombineLatest_<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
-        {
-            return new CombineLatest<TSource, TResult>(sources, resultSelector);
-        }
-
-        #endregion
-
-        #region + Concat +
-
-        public virtual IObservable<TSource> Concat<TSource>(IObservable<TSource> first, IObservable<TSource> second)
-        {
-            return Concat_(new[] { first, second });
-        }
-
-        public virtual IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources)
-        {
-            return Concat_(sources);
-        }
-
-        public virtual IObservable<TSource> Concat<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return Concat_(sources);
-        }
-
-        private static IObservable<TSource> Concat_<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return new Concat<TSource>(sources);
-        }
-
-        public virtual IObservable<TSource> Concat<TSource>(IObservable<IObservable<TSource>> sources)
-        {
-            return Concat_(sources);
-        }
-
-        public virtual IObservable<TSource> Concat<TSource>(IObservable<Task<TSource>> sources)
-        {
-            return Concat_(Select(sources, TaskObservableExtensions.ToObservable));
-        }
-
-        private static IObservable<TSource> Concat_<TSource>(IObservable<IObservable<TSource>> sources)
-        {
-            return new ConcatMany<TSource>(sources);
-        }
-
-        #endregion
-
-        #region + Merge +
-
-        public virtual IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources)
-        {
-            return Merge_(sources);
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IObservable<Task<TSource>> sources)
-        {
-            return new Merge<TSource>.Tasks(sources);
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IObservable<IObservable<TSource>> sources, int maxConcurrent)
-        {
-            return Merge_(sources, maxConcurrent);
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent)
-        {
-            return Merge_(sources.ToObservable(SchedulerDefaults.ConstantTimeOperations), maxConcurrent);
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler)
-        {
-            return Merge_(sources.ToObservable(scheduler), maxConcurrent);
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second)
-        {
-            return Merge_(new[] { first, second }.ToObservable(SchedulerDefaults.ConstantTimeOperations));
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IObservable<TSource> first, IObservable<TSource> second, IScheduler scheduler)
-        {
-            return Merge_(new[] { first, second }.ToObservable(scheduler));
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources)
-        {
-            return Merge_(sources.ToObservable(SchedulerDefaults.ConstantTimeOperations));
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources)
-        {
-            return Merge_(sources.ToObservable(scheduler));
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return Merge_(sources.ToObservable(SchedulerDefaults.ConstantTimeOperations));
-        }
-
-        public virtual IObservable<TSource> Merge<TSource>(IEnumerable<IObservable<TSource>> sources, IScheduler scheduler)
-        {
-            return Merge_(sources.ToObservable(scheduler));
-        }
+    private static IObservable<TSource> Merge_<TSource>(IObservable<IObservable<TSource>> sources, int maxConcurrent)
+    {
+        return new Merge<TSource>.ObservablesMaxConcurrency(sources, maxConcurrent);
+    }
 
-        private static IObservable<TSource> Merge_<TSource>(IObservable<IObservable<TSource>> sources)
-        {
-            return new Merge<TSource>.Observables(sources);
-        }
-
-        private static IObservable<TSource> Merge_<TSource>(IObservable<IObservable<TSource>> sources, int maxConcurrent)
-        {
-            return new Merge<TSource>.ObservablesMaxConcurrency(sources, maxConcurrent);
-        }
+    #endregion
 
-        #endregion
-
-        #region + OnErrorResumeNext +
+    #region + OnErrorResumeNext +
 
-        public virtual IObservable<TSource> OnErrorResumeNext<TSource>(IObservable<TSource> first, IObservable<TSource> second)
-        {
-            return OnErrorResumeNext_(new[] { first, second });
-        }
+    public virtual IObservable<TSource> OnErrorResumeNext<TSource>(IObservable<TSource> first, IObservable<TSource> second)
+    {
+        return OnErrorResumeNext_(new[] { first, second });
+    }
 
-        public virtual IObservable<TSource> OnErrorResumeNext<TSource>(params IObservable<TSource>[] sources)
-        {
-            return OnErrorResumeNext_(sources);
-        }
+    public virtual IObservable<TSource> OnErrorResumeNext<TSource>(params IObservable<TSource>[] sources)
+    {
+        return OnErrorResumeNext_(sources);
+    }
 
-        public virtual IObservable<TSource> OnErrorResumeNext<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return OnErrorResumeNext_(sources);
-        }
+    public virtual IObservable<TSource> OnErrorResumeNext<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return OnErrorResumeNext_(sources);
+    }
 
-        private static IObservable<TSource> OnErrorResumeNext_<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return new OnErrorResumeNext<TSource>(sources);
-        }
+    private static IObservable<TSource> OnErrorResumeNext_<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return new OnErrorResumeNext<TSource>(sources);
+    }
 
-        #endregion
+    #endregion
 
-        #region + SkipUntil +
+    #region + SkipUntil +
 
-        public virtual IObservable<TSource> SkipUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other)
-        {
-            return new SkipUntil<TSource, TOther>(source, other);
-        }
+    public virtual IObservable<TSource> SkipUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other)
+    {
+        return new SkipUntil<TSource, TOther>(source, other);
+    }
 
-        #endregion
+    #endregion
 
-        #region + Switch +
+    #region + Switch +
 
-        public virtual IObservable<TSource> Switch<TSource>(IObservable<IObservable<TSource>> sources)
-        {
-            return Switch_(sources);
-        }
+    public virtual IObservable<TSource> Switch<TSource>(IObservable<IObservable<TSource>> sources)
+    {
+        return Switch_(sources);
+    }
 
-        public virtual IObservable<TSource> Switch<TSource>(IObservable<Task<TSource>> sources)
-        {
-            return Switch_(Select(sources, TaskObservableExtensions.ToObservable));
-        }
+    public virtual IObservable<TSource> Switch<TSource>(IObservable<Task<TSource>> sources)
+    {
+        return Switch_(Select(sources, TaskObservableExtensions.ToObservable));
+    }
 
-        private static IObservable<TSource> Switch_<TSource>(IObservable<IObservable<TSource>> sources)
-        {
-            return new Switch<TSource>(sources);
-        }
+    private static IObservable<TSource> Switch_<TSource>(IObservable<IObservable<TSource>> sources)
+    {
+        return new Switch<TSource>(sources);
+    }
 
-        #endregion
+    #endregion
 
-        #region + TakeUntil +
+    #region + TakeUntil +
 
-        public virtual IObservable<TSource> TakeUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other)
-        {
-            return new TakeUntil<TSource, TOther>(source, other);
-        }
+    public virtual IObservable<TSource> TakeUntil<TSource, TOther>(IObservable<TSource> source, IObservable<TOther> other)
+    {
+        return new TakeUntil<TSource, TOther>(source, other);
+    }
 
-        public virtual IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, Func<TSource, bool> stopPredicate)
-        {
-            return new TakeUntilPredicate<TSource>(source, stopPredicate);
-        }
+    public virtual IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, Func<TSource, bool> stopPredicate)
+    {
+        return new TakeUntilPredicate<TSource>(source, stopPredicate);
+    }
 
-        #endregion
+    public virtual IObservable<TSource> TakeUntil<TSource>(IObservable<TSource> source, CancellationToken cancellationToken)
+    {
+        return new TakeUntilCancellationToken<TSource>(source, cancellationToken);
+    }
 
-        #region + Window +
+    #endregion
 
-        public virtual IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector)
-        {
-            return new Window<TSource, TWindowClosing>.Selector(source, windowClosingSelector);
-        }
+    #region + Window +
 
-        public virtual IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector)
-        {
-            return windowOpenings.GroupJoin(source, windowClosingSelector, _ => Observable.Empty<Unit>(), (_, window) => window);
-        }
+    public virtual IObservable<IObservable<TSource>> Window<TSource, TWindowClosing>(IObservable<TSource> source, Func<IObservable<TWindowClosing>> windowClosingSelector)
+    {
+        return new Window<TSource, TWindowClosing>.Selector(source, windowClosingSelector);
+    }
 
-        public virtual IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries)
-        {
-            return new Window<TSource, TWindowBoundary>.Boundaries(source, windowBoundaries);
-        }
+    public virtual IObservable<IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(IObservable<TSource> source, IObservable<TWindowOpening> windowOpenings, Func<TWindowOpening, IObservable<TWindowClosing>> windowClosingSelector)
+    {
+        return windowOpenings.GroupJoin(source, windowClosingSelector, _ => Observable.Empty<Unit>(), (_, window) => window);
+    }
 
-        #endregion
+    public virtual IObservable<IObservable<TSource>> Window<TSource, TWindowBoundary>(IObservable<TSource> source, IObservable<TWindowBoundary> windowBoundaries)
+    {
+        return new Window<TSource, TWindowBoundary>.Boundaries(source, windowBoundaries);
+    }
 
-        #region + WithLatestFrom +
+    #endregion
 
-        public virtual IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            return new WithLatestFrom<TFirst, TSecond, TResult>(first, second, resultSelector);
-        }
+    #region + WithLatestFrom +
 
-        #endregion
+    public virtual IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
+    {
+        return new WithLatestFrom<TFirst, TSecond, TResult>(first, second, resultSelector);
+    }
 
-        #region + Zip +
+    #endregion
 
-        public virtual IObservable<TResult> Zip<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            return new Zip<TFirst, TSecond, TResult>.Observable(first, second, resultSelector);
-        }
+    #region + Zip +
 
-        public virtual IObservable<TResult> Zip<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
-        {
-            return Zip_(sources).Select(resultSelector);
-        }
+    public virtual IObservable<TResult> Zip<TFirst, TSecond, TResult>(IObservable<TFirst> first, IObservable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
+    {
+        return new Zip<TFirst, TSecond, TResult>.Observable(first, second, resultSelector);
+    }
 
-        public virtual IObservable<IList<TSource>> Zip<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return Zip_(sources);
-        }
+    public virtual IObservable<TResult> Zip<TSource, TResult>(IEnumerable<IObservable<TSource>> sources, Func<IList<TSource>, TResult> resultSelector)
+    {
+        return Zip_(sources).Select(resultSelector);
+    }
 
-        public virtual IObservable<IList<TSource>> Zip<TSource>(params IObservable<TSource>[] sources)
-        {
-            return Zip_(sources);
-        }
+    public virtual IObservable<IList<TSource>> Zip<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return Zip_(sources);
+    }
 
-        private static IObservable<IList<TSource>> Zip_<TSource>(IEnumerable<IObservable<TSource>> sources)
-        {
-            return new Zip<TSource>(sources);
-        }
+    public virtual IObservable<IList<TSource>> Zip<TSource>(params IObservable<TSource>[] sources)
+    {
+        return Zip_(sources);
+    }
 
-        public virtual IObservable<TResult> Zip<TFirst, TSecond, TResult>(IObservable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
-        {
-            return new Zip<TFirst, TSecond, TResult>.Enumerable(first, second, resultSelector);
-        }
+    private static IObservable<IList<TSource>> Zip_<TSource>(IEnumerable<IObservable<TSource>> sources)
+    {
+        return new Zip<TSource>(sources);
+    }
 
-        #endregion
+    public virtual IObservable<TResult> Zip<TFirst, TSecond, TResult>(IObservable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
+    {
+        return new Zip<TFirst, TSecond, TResult>.Enumerable(first, second, resultSelector);
     }
+
+    #endregion
 }
diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs
index c55ebd2f0..8abcaca5b 100644
--- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs
+++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs
@@ -2,863 +2,924 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
+
+namespace ReactiveTests.Tests;
+
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Threading;
+
 using Microsoft.Reactive.Testing;
-using ReactiveTests.Dummies;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
+using ReactiveTests.Dummies;
+
 using Assert = Xunit.Assert;
 
-namespace ReactiveTests.Tests
+[TestClass]
+public class TakeUntilTest : ReactiveTest
 {
-    [TestClass]
-    public class TakeUntilTest : ReactiveTest
-    {
-        #region + Observable +
-
-        [TestMethod]
-        public void TakeUntil_ArgumentChecking()
-        {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int, int>(null, DummyObservable<int>.Instance));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int, int>(DummyObservable<int>.Instance, null));
-        }
-
-        [TestMethod]
-        public void TakeUntil_Preempt_SomeData_Next()
-        {
-            var scheduler = new TestScheduler();
-
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnNext(230, 4),
-                OnNext(240, 5),
-                OnCompleted<int>(250)
-            );
-
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(225, 99),
-                OnCompleted<int>(230)
-            );
-
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+    #region + Observable +
 
-            res.Messages.AssertEqual(
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnCompleted<int>(225)
-            );
-
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
-
-        [TestMethod]
-        public void TakeUntil_Preempt_SomeData_Error()
-        {
-            var scheduler = new TestScheduler();
-
-            var ex = new Exception();
-
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnNext(230, 4),
-                OnNext(240, 5),
-                OnCompleted<int>(250)
-            );
-
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnError<int>(225, ex)
-            );
-
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
-
-            res.Messages.AssertEqual(
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnError<int>(225, ex)
-            );
-
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
-
-        [TestMethod]
-        public void TakeUntil_NoPreempt_SomeData_Empty()
-        {
-            var scheduler = new TestScheduler();
-
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnNext(230, 4),
-                OnNext(240, 5),
-                OnCompleted<int>(250)
-            );
-
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnCompleted<int>(225)
-            );
-
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
-
-            res.Messages.AssertEqual(
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnNext(230, 4),
-                OnNext(240, 5),
-                OnCompleted<int>(250)
-            );
-
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 250)
-            );
+    [TestMethod]
+    public void TakeUntil_ArgumentChecking()
+    {
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int, int>(null, DummyObservable<int>.Instance));
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int, int>(DummyObservable<int>.Instance, null));
+    }
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
+    [TestMethod]
+    public void TakeUntil_Preempt_SomeData_Next()
+    {
+        var scheduler = new TestScheduler();
+
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnNext(230, 4),
+            OnNext(240, 5),
+            OnCompleted<int>(250)
+        );
+
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(225, 99),
+            OnCompleted<int>(230)
+        );
+
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnCompleted<int>(225)
+        );
+
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-        [TestMethod]
-        public void TakeUntil_NoPreempt_SomeData_Never()
-        {
-            var scheduler = new TestScheduler();
-
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnNext(230, 4),
-                OnNext(240, 5),
-                OnCompleted<int>(250)
-            );
+    [TestMethod]
+    public void TakeUntil_Preempt_SomeData_Error()
+    {
+        var scheduler = new TestScheduler();
+
+        var ex = new Exception();
+
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnNext(230, 4),
+            OnNext(240, 5),
+            OnCompleted<int>(250)
+        );
+
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnError<int>(225, ex)
+        );
+
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnError<int>(225, ex)
+        );
+
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1)
-            );
+    [TestMethod]
+    public void TakeUntil_NoPreempt_SomeData_Empty()
+    {
+        var scheduler = new TestScheduler();
+
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnNext(230, 4),
+            OnNext(240, 5),
+            OnCompleted<int>(250)
+        );
+
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnCompleted<int>(225)
+        );
+
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnNext(230, 4),
+            OnNext(240, 5),
+            OnCompleted<int>(250)
+        );
+
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 250)
+        );
+
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+    [TestMethod]
+    public void TakeUntil_NoPreempt_SomeData_Never()
+    {
+        var scheduler = new TestScheduler();
+
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnNext(230, 4),
+            OnNext(240, 5),
+            OnCompleted<int>(250)
+        );
+
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1)
+        );
+
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 2),
+            OnNext(220, 3),
+            OnNext(230, 4),
+            OnNext(240, 5),
+            OnCompleted<int>(250)
+        );
+
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 250)
+        );
+
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 250)
+        );
+    }
 
-            res.Messages.AssertEqual(
-                OnNext(210, 2),
-                OnNext(220, 3),
-                OnNext(230, 4),
-                OnNext(240, 5),
-                OnCompleted<int>(250)
-            );
+    [TestMethod]
+    public void TakeUntil_Preempt_Never_Next()
+    {
+        var scheduler = new TestScheduler();
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 250)
-            );
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1)
+        );
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 250)
-            );
-        }
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(225, 2), //!
+            OnCompleted<int>(250)
+        );
 
-        [TestMethod]
-        public void TakeUntil_Preempt_Never_Next()
-        {
-            var scheduler = new TestScheduler();
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1)
-            );
+        res.Messages.AssertEqual(
+            OnCompleted<int>(225)
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(225, 2), //!
-                OnCompleted<int>(250)
-            );
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-            res.Messages.AssertEqual(
-                OnCompleted<int>(225)
-            );
+    [TestMethod]
+    public void TakeUntil_Preempt_Never_Error()
+    {
+        var scheduler = new TestScheduler();
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
+        var ex = new Exception();
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1)
+        );
 
-        [TestMethod]
-        public void TakeUntil_Preempt_Never_Error()
-        {
-            var scheduler = new TestScheduler();
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnError<int>(225, ex)
+        );
 
-            var ex = new Exception();
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1)
-            );
+        res.Messages.AssertEqual(
+            OnError<int>(225, ex)
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnError<int>(225, ex)
-            );
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-            res.Messages.AssertEqual(
-                OnError<int>(225, ex)
-            );
+    [TestMethod]
+    public void TakeUntil_NoPreempt_Never_Empty()
+    {
+        var scheduler = new TestScheduler();
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1)
+        );
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnCompleted<int>(225)
+        );
 
-        [TestMethod]
-        public void TakeUntil_NoPreempt_Never_Empty()
-        {
-            var scheduler = new TestScheduler();
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1)
-            );
+        res.Messages.AssertEqual(
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnCompleted<int>(225)
-            );
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */)
+        );
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-            res.Messages.AssertEqual(
-            );
+    [TestMethod]
+    public void TakeUntil_NoPreempt_Never_Never()
+    {
+        var scheduler = new TestScheduler();
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */)
-            );
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1)
+        );
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1)
+        );
 
-        [TestMethod]
-        public void TakeUntil_NoPreempt_Never_Never()
-        {
-            var scheduler = new TestScheduler();
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1)
-            );
+        res.Messages.AssertEqual(
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1)
-            );
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 1000)
+        );
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 1000)
+        );
+    }
 
-            res.Messages.AssertEqual(
-            );
+    [TestMethod]
+    public void TakeUntil_Preempt_BeforeFirstProduced()
+    {
+        var scheduler = new TestScheduler();
+
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(230, 2),
+            OnCompleted<int>(240)
+        );
+
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(210, 2), //!
+            OnCompleted<int>(220)
+        );
+
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
+
+        res.Messages.AssertEqual(
+            OnCompleted<int>(210)
+        );
+
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 210)
+        );
+
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 210)
+        );
+    }
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 1000)
-            );
+    [TestMethod]
+    public void TakeUntil_Preempt_BeforeFirstProduced_RemainSilentAndProperDisposed()
+    {
+        var scheduler = new TestScheduler();
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 1000)
-            );
-        }
+        var sourceNotDisposed = false;
 
-        [TestMethod]
-        public void TakeUntil_Preempt_BeforeFirstProduced()
-        {
-            var scheduler = new TestScheduler();
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnError<int>(215, new Exception()), // should not come
+            OnCompleted<int>(240)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(230, 2),
-                OnCompleted<int>(240)
-            );
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(210, 2), //!
+            OnCompleted<int>(220)
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(210, 2), //!
-                OnCompleted<int>(220)
-            );
+        var res = scheduler.Start(() =>
+            l.Do(_ => sourceNotDisposed = true).TakeUntil(r)
+        );
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+        res.Messages.AssertEqual(
+            OnCompleted<int>(210)
+        );
 
-            res.Messages.AssertEqual(
-                OnCompleted<int>(210)
-            );
+        Assert.False(sourceNotDisposed);
+    }
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 210)
-            );
+    [TestMethod]
+    public void TakeUntil_NoPreempt_AfterLastProduced_ProperDisposedSignal()
+    {
+        var scheduler = new TestScheduler();
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 210)
-            );
-        }
+        var signalNotDisposed = false;
 
-        [TestMethod]
-        public void TakeUntil_Preempt_BeforeFirstProduced_RemainSilentAndProperDisposed()
-        {
-            var scheduler = new TestScheduler();
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(230, 2),
+            OnCompleted<int>(240)
+        );
 
-            var sourceNotDisposed = false;
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(250, 2),
+            OnCompleted<int>(260)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnError<int>(215, new Exception()), // should not come
-                OnCompleted<int>(240)
-            );
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r.Do(_ => signalNotDisposed = true))
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(210, 2), //!
-                OnCompleted<int>(220)
-            );
+        res.Messages.AssertEqual(
+            OnNext(230, 2),
+            OnCompleted<int>(240)
+        );
 
-            var res = scheduler.Start(() =>
-                l.Do(_ => sourceNotDisposed = true).TakeUntil(r)
-            );
+        Assert.False(signalNotDisposed);
+    }
 
-            res.Messages.AssertEqual(
-                OnCompleted<int>(210)
-            );
+    [TestMethod]
+    public void TakeUntil_Error_Some()
+    {
+        var scheduler = new TestScheduler();
 
-            Assert.False(sourceNotDisposed);
-        }
+        var ex = new Exception();
 
-        [TestMethod]
-        public void TakeUntil_NoPreempt_AfterLastProduced_ProperDisposedSignal()
-        {
-            var scheduler = new TestScheduler();
+        var l = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnError<int>(225, ex)
+        );
 
-            var signalNotDisposed = false;
+        var r = scheduler.CreateHotObservable(
+            OnNext(150, 1),
+            OnNext(240, 2)
+        );
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(230, 2),
-                OnCompleted<int>(240)
-            );
+        var res = scheduler.Start(() =>
+            l.TakeUntil(r)
+        );
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(250, 2),
-                OnCompleted<int>(260)
-            );
+        res.Messages.AssertEqual(
+            OnError<int>(225, ex)
+        );
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r.Do(_ => signalNotDisposed = true))
-            );
+        l.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
 
-            res.Messages.AssertEqual(
-                OnNext(230, 2),
-                OnCompleted<int>(240)
-            );
-
-            Assert.False(signalNotDisposed);
-        }
-
-        [TestMethod]
-        public void TakeUntil_Error_Some()
-        {
-            var scheduler = new TestScheduler();
-
-            var ex = new Exception();
+        r.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-            var l = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnError<int>(225, ex)
-            );
+    [TestMethod]
+    public void TakeUntil_Immediate()
+    {
+        var scheduler = new TestScheduler();
 
-            var r = scheduler.CreateHotObservable(
-                OnNext(150, 1),
-                OnNext(240, 2)
-            );
+        var xs = Observable.Return(1);
+        var ys = Observable.Return("bar");
 
-            var res = scheduler.Start(() =>
-                l.TakeUntil(r)
-            );
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(ys)
+        );
 
-            res.Messages.AssertEqual(
-                OnError<int>(225, ex)
-            );
+        res.Messages.AssertEqual(
+            OnCompleted<int>(200)
+        );
+    }
+    #endregion
 
-            l.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
+    #region + Timed +
 
-            r.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
+    [TestMethod]
+    public void TakeUntil_Timed_ArgumentChecking()
+    {
+        var xs = Observable.Return(42);
 
-        [TestMethod]
-        public void TakeUntil_Immediate()
-        {
-            var scheduler = new TestScheduler();
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(default(IObservable<int>), DateTimeOffset.Now));
 
-            var xs = Observable.Return(1);
-            var ys = Observable.Return("bar");
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(default(IObservable<int>), DateTimeOffset.Now, Scheduler.Default));
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(xs, DateTimeOffset.Now, default));
+    }
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(ys)
-            );
+    [TestMethod]
+    public void TakeUntil_Zero()
+    {
+        var scheduler = new TestScheduler();
 
-            res.Messages.AssertEqual(
-                OnCompleted<int>(200)
-            );
-        }
-        #endregion
+        var xs = scheduler.CreateHotObservable(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnCompleted<int>(230)
+        );
 
-        #region + Timed +
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(), scheduler)
+        );
 
-        [TestMethod]
-        public void TakeUntil_Timed_ArgumentChecking()
-        {
-            var xs = Observable.Return(42);
+        res.Messages.AssertEqual(
+            OnCompleted<int>(201)
+        );
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(default(IObservable<int>), DateTimeOffset.Now));
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 201)
+        );
+    }
 
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(default(IObservable<int>), DateTimeOffset.Now, Scheduler.Default));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(xs, DateTimeOffset.Now, default));
-        }
+    [TestMethod]
+    public void TakeUntil_Some()
+    {
+        var scheduler = new TestScheduler();
+
+        var xs = scheduler.CreateHotObservable(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnCompleted<int>(240)
+        );
+
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(225, TimeSpan.Zero), scheduler)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnCompleted<int>(225)
+        );
+
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 225)
+        );
+    }
 
-        [TestMethod]
-        public void TakeUntil_Zero()
-        {
-            var scheduler = new TestScheduler();
+    [TestMethod]
+    public void TakeUntil_Late()
+    {
+        var scheduler = new TestScheduler();
+
+        var xs = scheduler.CreateHotObservable(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnCompleted<int>(230)
+        );
+
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(250, TimeSpan.Zero), scheduler)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnCompleted<int>(230)
+        );
+
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 230)
+        );
+    }
 
-            var xs = scheduler.CreateHotObservable(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnCompleted<int>(230)
-            );
+    [TestMethod]
+    public void TakeUntil_Error()
+    {
+        var scheduler = new TestScheduler();
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(), scheduler)
-            );
+        var ex = new Exception();
 
-            res.Messages.AssertEqual(
-                OnCompleted<int>(201)
-            );
+        var xs = scheduler.CreateHotObservable(
+            OnError<int>(210, ex)
+        );
 
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 201)
-            );
-        }
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(250, TimeSpan.Zero), scheduler)
+        );
 
-        [TestMethod]
-        public void TakeUntil_Some()
-        {
-            var scheduler = new TestScheduler();
+        res.Messages.AssertEqual(
+            OnError<int>(210, ex)
+        );
 
-            var xs = scheduler.CreateHotObservable(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnCompleted<int>(240)
-            );
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 210)
+        );
+    }
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(225, TimeSpan.Zero), scheduler)
-            );
+    [TestMethod]
+    public void TakeUntil_Never()
+    {
+        var scheduler = new TestScheduler();
 
-            res.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnCompleted<int>(225)
-            );
+        var ex = new Exception();
 
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 225)
-            );
-        }
+        var xs = scheduler.CreateHotObservable<int>(
+        );
 
-        [TestMethod]
-        public void TakeUntil_Late()
-        {
-            var scheduler = new TestScheduler();
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(250, TimeSpan.Zero), scheduler)
+        );
 
-            var xs = scheduler.CreateHotObservable(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnCompleted<int>(230)
-            );
+        res.Messages.AssertEqual(
+            OnCompleted<int>(250)
+        );
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(250, TimeSpan.Zero), scheduler)
-            );
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 250)
+        );
+    }
 
-            res.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnCompleted<int>(230)
-            );
+    [TestMethod]
+    public void TakeUntil_Twice1()
+    {
+        var scheduler = new TestScheduler();
+
+        var ex = new Exception();
+
+        var xs = scheduler.CreateHotObservable(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnNext(240, 4),
+            OnNext(250, 5),
+            OnNext(260, 6),
+            OnCompleted<int>(270)
+        );
+
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(255, TimeSpan.Zero), scheduler).TakeUntil(new DateTimeOffset(235, TimeSpan.Zero), scheduler)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnCompleted<int>(235)
+        );
+
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 235)
+        );
+    }
 
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 230)
-            );
-        }
+    [TestMethod]
+    public void TakeUntil_Twice2()
+    {
+        var scheduler = new TestScheduler();
+
+        var ex = new Exception();
+
+        var xs = scheduler.CreateHotObservable(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnNext(240, 4),
+            OnNext(250, 5),
+            OnNext(260, 6),
+            OnCompleted<int>(270)
+        );
+
+        var res = scheduler.Start(() =>
+            xs.TakeUntil(new DateTimeOffset(235, TimeSpan.Zero), scheduler).TakeUntil(new DateTimeOffset(255, TimeSpan.Zero), scheduler)
+        );
+
+        res.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnCompleted<int>(235)
+        );
+
+        xs.Subscriptions.AssertEqual(
+            Subscribe(200, 235)
+        );
+    }
 
-        [TestMethod]
-        public void TakeUntil_Error()
-        {
-            var scheduler = new TestScheduler();
+    [TestMethod]
+    public void TakeUntil_Default()
+    {
+        var xs = Observable.Range(0, 10, Scheduler.Default);
 
-            var ex = new Exception();
+        var res = xs.TakeUntil(DateTimeOffset.Now.AddMinutes(1));
 
-            var xs = scheduler.CreateHotObservable(
-                OnError<int>(210, ex)
-            );
+        var e = new ManualResetEvent(false);
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(250, TimeSpan.Zero), scheduler)
-            );
+        var lst = new List<int>();
+        res.Subscribe(
+            lst.Add,
+            () => e.Set()
+        );
 
-            res.Messages.AssertEqual(
-                OnError<int>(210, ex)
-            );
+        e.WaitOne();
 
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 210)
-            );
-        }
+        Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10)));
+    }
 
-        [TestMethod]
-        public void TakeUntil_Never()
-        {
-            var scheduler = new TestScheduler();
+    #endregion
 
-            var ex = new Exception();
+    #region + Predicate +
 
-            var xs = scheduler.CreateHotObservable<int>(
-            );
+    [TestMethod]
+    public void TakeUntil_Predicate_ArgumentChecking()
+    {
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int>(null, v => true));
+        ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(DummyObservable<int>.Instance, null));
+    }
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(250, TimeSpan.Zero), scheduler)
-            );
+    [TestMethod]
+    public void TakeUntil_Predicate_Basic()
+    {
+        var scheduler = new TestScheduler();
+
+        var source = scheduler.CreateColdObservable(
+                OnNext(10, 1),
+                OnNext(20, 2),
+                OnNext(30, 3),
+                OnNext(40, 4),
+                OnNext(50, 5),
+                OnNext(60, 6),
+                OnNext(70, 7),
+                OnNext(80, 8),
+                OnNext(90, 9),
+                OnCompleted<int>(100)
+            );
+
+        var result = scheduler.Start(() => source.TakeUntil(v => v == 5));
+
+        result.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnNext(240, 4),
+            OnNext(250, 5),
+            OnCompleted<int>(250)
+        );
+
+        source.Subscriptions.AssertEqual(
+            Subscribe(200, 250)
+        );
+    }
 
-            res.Messages.AssertEqual(
-                OnCompleted<int>(250)
-            );
+    [TestMethod]
+    public void TakeUntil_Predicate_True()
+    {
+        var scheduler = new TestScheduler();
+
+        var source = scheduler.CreateColdObservable(
+                OnNext(10, 1),
+                OnNext(20, 2),
+                OnNext(30, 3),
+                OnNext(40, 4),
+                OnNext(50, 5),
+                OnNext(60, 6),
+                OnNext(70, 7),
+                OnNext(80, 8),
+                OnNext(90, 9),
+                OnCompleted<int>(100)
+            );
+
+        var result = scheduler.Start(() => source.TakeUntil(v => true));
+
+        result.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnCompleted<int>(210)
+        );
+
+        source.Subscriptions.AssertEqual(
+            Subscribe(200, 210)
+        );
+    }
 
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 250)
-            );
-        }
+    [TestMethod]
+    public void TakeUntil_Predicate_False()
+    {
+        var scheduler = new TestScheduler();
+
+        var source = scheduler.CreateColdObservable(
+                OnNext(10, 1),
+                OnNext(20, 2),
+                OnNext(30, 3),
+                OnNext(40, 4),
+                OnNext(50, 5),
+                OnNext(60, 6),
+                OnNext(70, 7),
+                OnNext(80, 8),
+                OnNext(90, 9),
+                OnCompleted<int>(100)
+            );
+
+        var result = scheduler.Start(() => source.TakeUntil(v => false));
+
+        result.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnNext(240, 4),
+            OnNext(250, 5),
+            OnNext(260, 6),
+            OnNext(270, 7),
+            OnNext(280, 8),
+            OnNext(290, 9),
+            OnCompleted<int>(300)
+        );
+
+        source.Subscriptions.AssertEqual(
+            Subscribe(200, 300)
+        );
+    }
 
-        [TestMethod]
-        public void TakeUntil_Twice1()
-        {
-            var scheduler = new TestScheduler();
+    [TestMethod]
+    public void TakeUntil_Predicate_Error()
+    {
+        var scheduler = new TestScheduler();
 
-            var ex = new Exception();
+        var ex = new InvalidOperationException();
 
-            var xs = scheduler.CreateHotObservable(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnNext(240, 4),
-                OnNext(250, 5),
-                OnNext(260, 6),
-                OnCompleted<int>(270)
+        var source = scheduler.CreateColdObservable(
+                OnNext(10, 1),
+                OnNext(20, 2),
+                OnNext(30, 3),
+                OnError<int>(40, ex)
             );
 
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(255, TimeSpan.Zero), scheduler).TakeUntil(new DateTimeOffset(235, TimeSpan.Zero), scheduler)
-            );
+        var result = scheduler.Start(() => source.TakeUntil(v => false));
 
-            res.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnCompleted<int>(235)
-            );
+        result.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnError<int>(240, ex)
+        );
 
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 235)
-            );
-        }
+        source.Subscriptions.AssertEqual(
+            Subscribe(200, 240)
+        );
+    }
 
-        [TestMethod]
-        public void TakeUntil_Twice2()
-        {
-            var scheduler = new TestScheduler();
+    [TestMethod]
+    public void TakeUntil_Predicate_Crash()
+    {
+        var scheduler = new TestScheduler();
 
-            var ex = new Exception();
+        var ex = new InvalidOperationException();
 
-            var xs = scheduler.CreateHotObservable(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
+        var source = scheduler.CreateColdObservable(
+                OnNext(10, 1),
+                OnNext(20, 2),
+                OnNext(30, 3),
                 OnNext(240, 4),
                 OnNext(250, 5),
-                OnNext(260, 6),
-                OnCompleted<int>(270)
-            );
-
-            var res = scheduler.Start(() =>
-                xs.TakeUntil(new DateTimeOffset(235, TimeSpan.Zero), scheduler).TakeUntil(new DateTimeOffset(255, TimeSpan.Zero), scheduler)
-            );
-
-            res.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnCompleted<int>(235)
-            );
-
-            xs.Subscriptions.AssertEqual(
-                Subscribe(200, 235)
-            );
-        }
-
-        [TestMethod]
-        public void TakeUntil_Default()
-        {
-            var xs = Observable.Range(0, 10, Scheduler.Default);
-
-            var res = xs.TakeUntil(DateTimeOffset.Now.AddMinutes(1));
-
-            var e = new ManualResetEvent(false);
-
-            var lst = new List<int>();
-            res.Subscribe(
-                lst.Add,
-                () => e.Set()
+                OnCompleted<int>(260)
             );
 
-            e.WaitOne();
-
-            Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10)));
-        }
-
-        #endregion
-
-        #region + Predicate +
-
-        [TestMethod]
-        public void TakeUntil_Predicate_ArgumentChecking()
-        {
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil<int>(null, v => true));
-            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.TakeUntil(DummyObservable<int>.Instance, null));
-        }
-
-        [TestMethod]
-        public void TakeUntil_Predicate_Basic()
+        var result = scheduler.Start(() => source.TakeUntil(v =>
         {
-            var scheduler = new TestScheduler();
-
-            var source = scheduler.CreateColdObservable(
-                    OnNext(10, 1),
-                    OnNext(20, 2),
-                    OnNext(30, 3),
-                    OnNext(40, 4),
-                    OnNext(50, 5),
-                    OnNext(60, 6),
-                    OnNext(70, 7),
-                    OnNext(80, 8),
-                    OnNext(90, 9),
-                    OnCompleted<int>(100)
-                );
-
-            var result = scheduler.Start(() => source.TakeUntil(v => v == 5));
-
-            result.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnNext(240, 4),
-                OnNext(250, 5),
-                OnCompleted<int>(250)
-            );
-
-            source.Subscriptions.AssertEqual(
-                Subscribe(200, 250)
-            );
-        }
+            if (v == 3)
+            {
+                throw ex;
+            }
+            return false;
+        }));
+
+        result.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnError<int>(230, ex)
+        );
+
+        source.Subscriptions.AssertEqual(
+            Subscribe(200, 230)
+        );
+    }
 
-        [TestMethod]
-        public void TakeUntil_Predicate_True()
-        {
-            var scheduler = new TestScheduler();
-
-            var source = scheduler.CreateColdObservable(
-                    OnNext(10, 1),
-                    OnNext(20, 2),
-                    OnNext(30, 3),
-                    OnNext(40, 4),
-                    OnNext(50, 5),
-                    OnNext(60, 6),
-                    OnNext(70, 7),
-                    OnNext(80, 8),
-                    OnNext(90, 9),
-                    OnCompleted<int>(100)
-                );
-
-            var result = scheduler.Start(() => source.TakeUntil(v => true));
-
-            result.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnCompleted<int>(210)
-            );
+    #endregion
 
-            source.Subscriptions.AssertEqual(
-                Subscribe(200, 210)
-            );
-        }
+    #region + CancellationToken +
 
-        [TestMethod]
-        public void TakeUntil_Predicate_False()
-        {
-            var scheduler = new TestScheduler();
-
-            var source = scheduler.CreateColdObservable(
-                    OnNext(10, 1),
-                    OnNext(20, 2),
-                    OnNext(30, 3),
-                    OnNext(40, 4),
-                    OnNext(50, 5),
-                    OnNext(60, 6),
-                    OnNext(70, 7),
-                    OnNext(80, 8),
-                    OnNext(90, 9),
-                    OnCompleted<int>(100)
-                );
-
-            var result = scheduler.Start(() => source.TakeUntil(v => false));
-
-            result.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnNext(240, 4),
-                OnNext(250, 5),
-                OnNext(260, 6),
-                OnNext(270, 7),
-                OnNext(280, 8),
-                OnNext(290, 9),
-                OnCompleted<int>(300)
-            );
+    [TestMethod]
+    public void TakeUntil_CancellationToken_BasicCancelation()
+    {
+        var scheduler = new TestScheduler();
+        var tokenSource = new CancellationTokenSource();
 
-            source.Subscriptions.AssertEqual(
-                Subscribe(200, 300)
+        var source = scheduler.CreateColdObservable(
+            OnNext(10, 1),
+            OnNext(20, 2),
+            OnNext(30, 3),
+            OnNext(40, 4),
+            OnNext(50, 5),
+            OnCompleted<int>(260)
             );
-        }
-
-        [TestMethod]
-        public void TakeUntil_Predicate_Error()
-        {
-            var scheduler = new TestScheduler();
 
-            var ex = new InvalidOperationException();
+        scheduler.ScheduleAbsolute(235, () => tokenSource.Cancel());
 
-            var source = scheduler.CreateColdObservable(
-                    OnNext(10, 1),
-                    OnNext(20, 2),
-                    OnNext(30, 3),
-                    OnError<int>(40, ex)
-                );
+        var result = scheduler.Start(() => source.TakeUntil(tokenSource.Token));
 
-            var result = scheduler.Start(() => source.TakeUntil(v => false));
-
-            result.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnError<int>(240, ex)
-            );
-
-            source.Subscriptions.AssertEqual(
-                Subscribe(200, 240)
-            );
-        }
+        result.Messages.AssertEqual(
+            OnNext(210, 1),
+            OnNext(220, 2),
+            OnNext(230, 3),
+            OnCompleted<int>(235)
+        );
 
-        [TestMethod]
-        public void TakeUntil_Predicate_Crash()
-        {
-            var scheduler = new TestScheduler();
-
-            var ex = new InvalidOperationException();
+        source.Subscriptions.AssertEqual(
+            Subscribe(200, 235)
+        );
+    }
 
-            var source = scheduler.CreateColdObservable(
-                    OnNext(10, 1),
-                    OnNext(20, 2),
-                    OnNext(30, 3),
-                    OnNext(240, 4),
-                    OnNext(250, 5),
-                    OnCompleted<int>(260)
-                );
+    [TestMethod]
+    public void TakeUntil_CancellationToken_AlreadyCanceled()
+    {
+        var scheduler = new TestScheduler();
+        var tokenSource = new CancellationTokenSource();
+        tokenSource.Cancel();
 
-            var result = scheduler.Start(() => source.TakeUntil(v =>
-            {
-                if (v == 3)
-                {
-                    throw ex;
-                }
-                return false;
-            }));
-
-            result.Messages.AssertEqual(
-                OnNext(210, 1),
-                OnNext(220, 2),
-                OnNext(230, 3),
-                OnError<int>(230, ex)
+        var source = scheduler.CreateColdObservable(
+            OnNext(10, 1),
+            OnNext(20, 2),
+            OnNext(30, 3),
+            OnNext(40, 4),
+            OnNext(50, 5),
+            OnCompleted<int>(260)
             );
 
-            source.Subscriptions.AssertEqual(
-                Subscribe(200, 230)
-            );
-        }
+        var result = scheduler.Start(() => source.TakeUntil(tokenSource.Token));
 
-        #endregion
+        result.Messages.AssertEqual(
+            OnCompleted<int>(200)
+        );
 
+        Assert.Empty(source.Subscriptions);
     }
+
+    #endregion
 }