ReactiveUI.Primitives.Extensions.ReactiveExtensions
namespace ReactiveUI.Primitives.Extensions
{
public static class ReactiveExtensions
{
public sealed class <G>$B5EDD37094405E2F71002D8BA2403DF0
{
public static class <M>$FCF552C60A56716338EDFB2354758928
{
}
public IObservable<RxVoid> Start(ISequencer scheduler);
}
public sealed class <G>$F830E484A8557A46F6358729AAF16684
{
public static class <M>$1922CBB047539A25CBED1E743A2CA7C3
{
}
public IObservable<RxVoid> While(Action action);
public IObservable<RxVoid> While(Action action, ISequencer scheduler);
}
public sealed class <G>$B61E0FF937F973EAED7F3327436606B2
{
public static class <M>$39DA2E00724FA16D4C7BBBAB18301313
{
}
public IObservable<bool> CombineLatestValuesAreAllFalse();
public IObservable<bool> CombineLatestValuesAreAllTrue();
}
public sealed class <G>$E09FCB5EB13C1AE2FC524F6744DE5322<$T0>
{
public static class <M>$28EDA03CA84F5B82CE261A172FD7A22C
{
}
public IObservable<$T0> FromArray();
public IObservable<$T0> FromArray(ISequencer scheduler);
}
public sealed class <G>$80767F2C532B9E65196E252449966813<$T0>
{
public static class <M>$FB8D0D80EA7C528DABE310AE84173C54
{
}
public IObservable<$T0> WithLimitedConcurrency(int maxConcurrency);
}
public sealed class <G>$498F2E0BC0876DB43A47E978014B4705<$T0>
{
public static class <M>$AA4F153FCB36487CE1C2920FC5E14360
{
}
public IObservable<$T0> ForEach();
public IObservable<$T0> ForEach(ISequencer scheduler);
}
public sealed class <G>$3B40C44C69CF41A4A1D07F492CE9D6C3
{
public static class <M>$B0C31BEE526638F6F5F939270EAAE0E3
{
}
public IObservable<RxVoid> CatchReturnUnit();
}
public sealed class <G>$035B8B55A41C4BB126D0FAEA23B957AD<$T0>
{
public static class <M>$03F9C8576D16AC65FE5E5925DFCD6589
{
}
public static class <M>$452DFEA04C19F365E8ECF14DCABDBDEC
{
}
public IObservable<$T0> WhereIsNotNull();
public IObservable<RxVoid> AsSignal();
public IObservable<IList<$T0>> BufferUntilIdle(TimeSpan idleTime);
public IObservable<IList<$T0>> BufferUntilIdle(TimeSpan idleTime, ISequencer scheduler);
public IObservable<$T0> CatchIgnore<[System.Runtime.CompilerServices.Nullable(0)] TException>(Action<TException> errorAction) where TException : Exception;
public IObservable<Stale<$T0>> DetectStale(TimeSpan stalenessPeriod, ISequencer scheduler);
public IObservable<$T0> Conflate(TimeSpan minimumUpdatePeriod, ISequencer scheduler);
public IObservable<Heartbeat<$T0>> Heartbeat(TimeSpan heartbeatPeriod, ISequencer scheduler);
public IObservable<$T0> LatestOrDefault($T0 defaultValue);
public IObservable<$T0> LogErrors(Action<Exception> logger);
public IObservable<$T0> ObserveOnSafe(ISequencer scheduler);
public IObservable<$T0> ObserveOnIf(bool condition, ISequencer scheduler);
public IObservable<$T0> ObserveOnIf(bool condition, ISequencer trueScheduler, ISequencer falseScheduler);
public IObservable<$T0> ObserveOnIf(IObservable<bool> condition, ISequencer trueScheduler, ISequencer falseScheduler);
public IObservable<$T0> ObserveOnIf(IObservable<bool> condition, ISequencer scheduler);
public IObservable<$T0> SampleLatest(IObservable<object> trigger);
public IObservable<TAccumulate> ScanWithInitial<[System.Runtime.CompilerServices.Nullable(2)] TAccumulate>(TAccumulate initial, Func<TAccumulate, $T0, TAccumulate> accumulator);
public IObservable<$T0> Schedule(TimeSpan dueTime, ISequencer scheduler);
public IObservable<$T0> Schedule(DateTimeOffset dueTime, ISequencer scheduler);
public IObservable<$T0> Schedule(TimeSpan dueTime, ISequencer scheduler, Action<$T0> action);
public IObservable<$T0> Schedule(DateTimeOffset dueTime, ISequencer scheduler, Action<$T0> action);
public IObservable<$T0> Schedule(ISequencer scheduler, Func<$T0, $T0> function);
public IObservable<$T0> Schedule(TimeSpan dueTime, ISequencer scheduler, Func<$T0, $T0> function);
public IObservable<$T0> TakeUntil(Func<$T0, bool> predicate);
public IObservable<($T0 Value, IDisposable Sync)> SynchronizeSynchronous();
public IDisposable SubscribeSynchronous(Func<$T0, ValueTask> onNext, Action<Exception> onError, Action onCompleted);
public IDisposable SubscribeSynchronous(Func<$T0, ValueTask> onNext, Action<Exception> onError);
public IDisposable SubscribeSynchronous(Func<$T0, ValueTask> onNext, Action onCompleted);
public IDisposable SubscribeSynchronous(Func<$T0, ValueTask> onNext);
public IObservable<$T0> SwitchIfEmpty(IObservable<$T0> fallback);
public IObservable<($T0 Value, IDisposable Sync)> SynchronizeAsync();
public IDisposable SubscribeAsync(Func<$T0, ValueTask> onNext);
public IDisposable SubscribeAsync(Func<$T0, ValueTask> onNext, Action onCompleted);
public IDisposable SubscribeAsync(Func<$T0, ValueTask> onNext, Action<Exception> onError);
public IDisposable SubscribeAsync(Func<$T0, ValueTask> onNext, Action<Exception> onError, Action onCompleted);
public IObservable<$T0> CatchAndReturn($T0 fallback);
public IObservable<$T0> CatchAndReturn<[System.Runtime.CompilerServices.Nullable(0)] TException>(Func<TException, $T0> fallbackFactory) where TException : Exception;
public IObservable<$T0> ReplayLastOnSubscribe($T0 initialValue);
public IObservable<$T0> ThrottleFirst(TimeSpan window);
public IObservable<$T0> ThrottleFirst(TimeSpan window, ISequencer scheduler);
public IObservable<$T0> ThrottleUntilTrue(TimeSpan throttle, Func<$T0, bool> predicate);
public IObservable<$T0> ThrottleOnScheduler(TimeSpan timeSpan, ISequencer scheduler);
public Task<$T0> ToHotTask();
public ValueTask<$T0> ToHotValueTask();
public IObservable<$T0> ThrottleDistinct(TimeSpan throttle);
public IObservable<$T0> ThrottleDistinct(TimeSpan throttle, ISequencer scheduler);
public IObservable<$T0> DebounceImmediate(TimeSpan dueTime);
public IObservable<$T0> DebounceImmediate(TimeSpan dueTime, ISequencer scheduler);
public IObservable<$T0> DebounceUntil(TimeSpan debounce, Func<$T0, bool> condition);
public IObservable<$T0> DebounceUntil(TimeSpan debounce, Func<$T0, bool> condition, ISequencer scheduler);
public IObservable<TResult> SelectAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, CancellationToken, Task<TResult>> asyncSelector);
public IObservable<TResult> SelectAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, Task<TResult>> asyncSelector);
public IObservable<TResult> SelectAsyncSequential<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, Task<TResult>> selector);
public IObservable<TResult> SelectLatestAsync<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, Task<TResult>> selector);
public IObservable<TResult> SelectAsyncConcurrent<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, Task<TResult>> selector, int maxConcurrency);
public IObservable<($T0 Previous, $T0 Current)> Pairwise();
public (IObservable<$T0> True, IObservable<$T0> False) Partition(Func<$T0, bool> predicate);
public IObservable<IList<$T0>> BufferUntilInactive(TimeSpan inactivityPeriod);
public IObservable<IList<$T0>> BufferUntilInactive(TimeSpan inactivityPeriod, ISequencer scheduler);
public IObservable<$T0> WaitUntil(Func<$T0, bool> predicate);
public IObservable<$T0> DropIfBusy(Func<$T0, ValueTask> asyncAction);
public IObservable<$T0> DoOnSubscribe(Action action);
public IObservable<$T0> DoOnDispose(Action disposeAction);
public IObservable<TOut> WhereSelect<[System.Runtime.CompilerServices.Nullable(2)] TOut>(Func<$T0, bool> predicate, Func<$T0, TOut> selector);
public IObservable<$T0> CatchReturn($T0 fallback);
public IObservable<TResult> SelectConstant<[System.Runtime.CompilerServices.Nullable(2)] TResult>(TResult constant);
public IObservable<TOut> TrySelect<[System.Runtime.CompilerServices.Nullable(2)] TOut>(Func<$T0, TOut> selector);
public IObservable<TResult> SelectManyThen<[System.Runtime.CompilerServices.Nullable(2)] TMid, [System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, IObservable<TMid>> first, Func<TMid, IObservable<TResult>> second);
public IObservable<$T0> OnErrorRetry();
public IObservable<$T0> OnErrorRetry<[System.Runtime.CompilerServices.Nullable(0)] TException>(Action<TException> onError) where TException : Exception;
public IObservable<$T0> OnErrorRetry<[System.Runtime.CompilerServices.Nullable(0)] TException>(Action<TException> onError, TimeSpan delay) where TException : Exception;
public IObservable<$T0> OnErrorRetry<[System.Runtime.CompilerServices.Nullable(0)] TException>(Action<TException> onError, int retryCount) where TException : Exception;
public IObservable<$T0> OnErrorRetry<[System.Runtime.CompilerServices.Nullable(0)] TException>(Action<TException> onError, int retryCount, TimeSpan delay) where TException : Exception;
public IObservable<$T0> OnErrorRetry<[System.Runtime.CompilerServices.Nullable(0)] TException>(Action<TException> onError, int retryCount, TimeSpan delay, ISequencer delayScheduler) where TException : Exception;
public IObservable<$T0> RetryWithBackoff(int maxRetries, TimeSpan initialDelay);
public IObservable<$T0> RetryWithBackoff(int maxRetries, TimeSpan initialDelay, double backoffFactor, TimeSpan? maxDelay, ISequencer scheduler);
public IObservable<$T0> RetryWithDelay(int retryCount, Func<int, TimeSpan> delaySelector);
public IObservable<$T0> RetryForeverWithDelay(TimeSpan delay);
public IObservable<$T0> RetryWithFixedDelay(int retryCount, TimeSpan delay);
public IObservable<$T0> CatchIgnore();
}
public sealed class <G>$C858CEE6CA93E5FFE99CEFB940AFA807<$T0> where $T0 : struct, IComparable<$T0>
{
public static class <M>$AB32CDFA0150FE6708E3F654D3DF358D
{
}
public IObservable<$T0> GetMax(params IObservable<$T0>[] sources);
public IObservable<$T0> GetMin(params IObservable<$T0>[] sources);
}
public sealed class <G>$F0E92667E8F87055EA191553E578ACC3<$T0> where $T0 : class
{
public static class <M>$31BCBA00BDD545DCB7E708F1B528B47F
{
}
public IObservable<$T0> SkipWhileNull();
}
public sealed class <G>$3693006486B1CA02F5DE226CEE868034<$T0>
{
public static class <M>$9094B725371D54860067F014228FFEBF
{
}
public IObservable<$T0[]> Shuffle();
}
public sealed class <G>$C7914E4D537F20FB90EF1F016876A708
{
public static class <M>$82B3B3D197FB52FCE28EDD0F1394B24F
{
}
public IObservable<bool> Not();
public IObservable<bool> WhereTrue();
public IObservable<bool> WhereFalse();
}
public sealed class <G>$9964AF6A9D00B087C4B5A1C7CD037116
{
public static class <M>$3DD84C567ABF47CCFFE70584E68FF914
{
}
public IObservable<string> BufferUntil(char startsWith, char endsWith);
}
public sealed class <G>$F1A444EA3B59671175E9DE7A229B7442
{
public static class <M>$7DDFA0CDF2AD0FD36EC0EE3727EA812A
{
}
public IObservable<string> Filter(string regexPattern);
public IObservable<string> Filter(Regex regex);
}
public sealed class <G>$F25072AEE24A0B97D024EC21534B1A44<$T0>
{
public static class <M>$F0F4A4636B9BEAD1DC255BE3EDBA0775
{
}
public void OnNext(params $T0[] events);
}
public sealed class <G>$66BFDCA17E7B35F25AA2FCB25F60F5CC
{
public static class <M>$F615894BA0EC2CBC7027E85406647EA4
{
}
public IObservable<RxVoid> RunAll();
}
public sealed class <G>$C40C92331D96445F4B71B2F1DD60A4F6<$T0>
{
public static class <M>$FBBAD668249B9B2B2FD0979DC1103DFD
{
}
public IObservable<TResult> FirstMatchFromCandidates<[System.Runtime.CompilerServices.Nullable(2)] TRaw, [System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, IObservable<TRaw>> project, Func<TRaw, TResult> transform, Func<TResult, bool> predicate, TResult fallback);
}
public sealed class <G>$AFAFA12AE2D7D350C9A0FB7C22A6E201
{
public static class <M>$478841D7A46E7E8CA11683D608A9104D
{
}
public IDisposable ScheduleSafe(Action action);
public IDisposable ScheduleSafe(TimeSpan dueTime, Action action);
}
public sealed class <G>$1D881486B43E041E8970D4A6A566D537<$T0> where $T0 : IDisposable
{
public static class <M>$686DFEE181CF1499E45E0D0372F8FB2D
{
}
public IObservable<RxVoid> Using(Action<$T0> action);
public IObservable<RxVoid> Using(Action<$T0> action, ISequencer scheduler);
public IObservable<TResult> Using<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, TResult> function);
public IObservable<TResult> Using<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<$T0, TResult> function, ISequencer scheduler);
}
public sealed class <G>$B87FB99B0FC93086A396186AFB24677B<$T0> where $T0 : INotifyPropertyChanged
{
public static class <M>$292BA5A551D37588A1AB929D22C9329D
{
}
public IObservable<TProperty> ToPropertyObservable<[System.Runtime.CompilerServices.Nullable(2)] TProperty>(Expression<Func<$T0, TProperty>> propertyExpression);
}
public sealed class <G>$8048A6C8BE30A622530249B904B537EB<$T0>
{
public static class <M>$27139EB8CE0FD35E2437AF57CCA96FCC
{
}
public IObservable<$T0> ScheduleValue(TimeSpan dueTime, ISequencer scheduler);
public IObservable<$T0> ScheduleValue(DateTimeOffset dueTime, ISequencer scheduler);
public IObservable<$T0> ScheduleValue(TimeSpan dueTime, ISequencer scheduler, Action<$T0> action);
public IObservable<$T0> ScheduleValue(DateTimeOffset dueTime, ISequencer scheduler, Action<$T0> action);
public IObservable<$T0> ScheduleValue(ISequencer scheduler, Func<$T0, $T0> function);
public IObservable<$T0> ScheduleValue(TimeSpan dueTime, ISequencer scheduler, Func<$T0, $T0> function);
}
public sealed class <G>$AEF4692409D6751FA6D278B69B50C9D0
{
public static class <M>$3A074E4B37AE89D8145A3EA9491BC838
{
}
public IObservable<DateTime> SyncTimer();
public IObservable<DateTime> SyncTimer(ISequencer scheduler);
}
public static IObservable<RxVoid> Start(this Action action, ISequencer scheduler);
public static IObservable<RxVoid> While(this Func<bool> condition, Action action);
public static IObservable<RxVoid> While(this Func<bool> condition, Action action, ISequencer scheduler);
public static IObservable<bool> CombineLatestValuesAreAllFalse(this IEnumerable<IObservable<bool>> sources);
public static IObservable<bool> CombineLatestValuesAreAllTrue(this IEnumerable<IObservable<bool>> sources);
public static IObservable<T> FromArray<T>(this IEnumerable<T> source);
public static IObservable<T> FromArray<T>(this IEnumerable<T> source, ISequencer scheduler);
public static IObservable<T> WithLimitedConcurrency<T>(this IEnumerable<Task<T>> taskFunctions, int maxConcurrency);
public static IObservable<T> ForEach<T>(this IObservable<IEnumerable<T>> source);
public static IObservable<T> ForEach<T>(this IObservable<IEnumerable<T>> source, ISequencer scheduler);
public static IObservable<RxVoid> CatchReturnUnit(this IObservable<RxVoid> source);
public static IObservable<T> WhereIsNotNull<T>(this IObservable<T> source);
public static IObservable<RxVoid> AsSignal<T>(this IObservable<T> source);
public static IObservable<IList<T>> BufferUntilIdle<T>(this IObservable<T> source, TimeSpan idleTime);
public static IObservable<IList<T>> BufferUntilIdle<T>(this IObservable<T> source, TimeSpan idleTime, ISequencer scheduler);
public static IObservable<T> CatchIgnore<T, TException>(this IObservable<T> source, Action<TException> errorAction) where TException : Exception;
public static IObservable<Stale<T>> DetectStale<T>(this IObservable<T> source, TimeSpan stalenessPeriod, ISequencer scheduler);
public static IObservable<T> Conflate<T>(this IObservable<T> source, TimeSpan minimumUpdatePeriod, ISequencer scheduler);
public static IObservable<Heartbeat<T>> Heartbeat<T>(this IObservable<T> source, TimeSpan heartbeatPeriod, ISequencer scheduler);
public static IObservable<T> LatestOrDefault<T>(this IObservable<T> source, T defaultValue);
public static IObservable<T> LogErrors<T>(this IObservable<T> source, Action<Exception> logger);
public static IObservable<T> ObserveOnSafe<T>(this IObservable<T> source, ISequencer scheduler);
public static IObservable<T> ObserveOnIf<T>(this IObservable<T> source, bool condition, ISequencer scheduler);
public static IObservable<T> ObserveOnIf<T>(this IObservable<T> source, bool condition, ISequencer trueScheduler, ISequencer falseScheduler);
public static IObservable<T> ObserveOnIf<T>(this IObservable<T> source, IObservable<bool> condition, ISequencer trueScheduler, ISequencer falseScheduler);
public static IObservable<T> ObserveOnIf<T>(this IObservable<T> source, IObservable<bool> condition, ISequencer scheduler);
public static IObservable<T> SampleLatest<T>(this IObservable<T> source, IObservable<object> trigger);
public static IObservable<TAccumulate> ScanWithInitial<T, TAccumulate>(this IObservable<T> source, TAccumulate initial, Func<TAccumulate, T, TAccumulate> accumulator);
public static IObservable<T> Schedule<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer scheduler);
public static IObservable<T> Schedule<T>(this IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler);
public static IObservable<T> Schedule<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer scheduler, Action<T> action);
public static IObservable<T> Schedule<T>(this IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler, Action<T> action);
public static IObservable<T> Schedule<T>(this IObservable<T> source, ISequencer scheduler, Func<T, T> function);
public static IObservable<T> Schedule<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer scheduler, Func<T, T> function);
public static IObservable<T> TakeUntil<T>(this IObservable<T> source, Func<T, bool> predicate);
public static IObservable<(T Value, IDisposable Sync)> SynchronizeSynchronous<T>(this IObservable<T> source);
public static IDisposable SubscribeSynchronous<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action<Exception> onError, Action onCompleted);
public static IDisposable SubscribeSynchronous<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action<Exception> onError);
public static IDisposable SubscribeSynchronous<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action onCompleted);
public static IDisposable SubscribeSynchronous<T>(this IObservable<T> source, Func<T, ValueTask> onNext);
public static IObservable<T> SwitchIfEmpty<T>(this IObservable<T> source, IObservable<T> fallback);
public static IObservable<(T Value, IDisposable Sync)> SynchronizeAsync<T>(this IObservable<T> source);
public static IDisposable SubscribeAsync<T>(this IObservable<T> source, Func<T, ValueTask> onNext);
public static IDisposable SubscribeAsync<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action onCompleted);
public static IDisposable SubscribeAsync<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action<Exception> onError);
public static IDisposable SubscribeAsync<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action<Exception> onError, Action onCompleted);
public static IObservable<T> CatchAndReturn<T>(this IObservable<T> source, T fallback);
public static IObservable<T> CatchAndReturn<T, TException>(this IObservable<T> source, Func<TException, T> fallbackFactory) where TException : Exception;
public static IObservable<T> ReplayLastOnSubscribe<T>(this IObservable<T> source, T initialValue);
public static IObservable<T> ThrottleFirst<T>(this IObservable<T> source, TimeSpan window);
public static IObservable<T> ThrottleFirst<T>(this IObservable<T> source, TimeSpan window, ISequencer scheduler);
public static IObservable<T> ThrottleUntilTrue<T>(this IObservable<T> source, TimeSpan throttle, Func<T, bool> predicate);
public static IObservable<T> ThrottleOnScheduler<T>(this IObservable<T> source, TimeSpan timeSpan, ISequencer scheduler);
public static Task<T> ToHotTask<T>(this IObservable<T> source);
public static ValueTask<T> ToHotValueTask<T>(this IObservable<T> source);
public static IObservable<T> ThrottleDistinct<T>(this IObservable<T> source, TimeSpan throttle);
public static IObservable<T> ThrottleDistinct<T>(this IObservable<T> source, TimeSpan throttle, ISequencer scheduler);
public static IObservable<T> DebounceImmediate<T>(this IObservable<T> source, TimeSpan dueTime);
public static IObservable<T> DebounceImmediate<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer scheduler);
public static IObservable<T> DebounceUntil<T>(this IObservable<T> source, TimeSpan debounce, Func<T, bool> condition);
public static IObservable<T> DebounceUntil<T>(this IObservable<T> source, TimeSpan debounce, Func<T, bool> condition, ISequencer scheduler);
public static IObservable<TResult> SelectAsync<T, TResult>(this IObservable<T> source, Func<T, CancellationToken, Task<TResult>> asyncSelector);
public static IObservable<TResult> SelectAsync<T, TResult>(this IObservable<T> source, Func<T, Task<TResult>> asyncSelector);
public static IObservable<TResult> SelectAsyncSequential<T, TResult>(this IObservable<T> source, Func<T, Task<TResult>> selector);
public static IObservable<TResult> SelectLatestAsync<T, TResult>(this IObservable<T> source, Func<T, Task<TResult>> selector);
public static IObservable<TResult> SelectAsyncConcurrent<T, TResult>(this IObservable<T> source, Func<T, Task<TResult>> selector, int maxConcurrency);
public static IObservable<(T Previous, T Current)> Pairwise<T>(this IObservable<T> source);
public static (IObservable<T> True, IObservable<T> False) Partition<T>(this IObservable<T> source, Func<T, bool> predicate);
public static IObservable<IList<T>> BufferUntilInactive<T>(this IObservable<T> source, TimeSpan inactivityPeriod);
public static IObservable<IList<T>> BufferUntilInactive<T>(this IObservable<T> source, TimeSpan inactivityPeriod, ISequencer scheduler);
public static IObservable<T> WaitUntil<T>(this IObservable<T> source, Func<T, bool> predicate);
public static IObservable<T> DropIfBusy<T>(this IObservable<T> source, Func<T, ValueTask> asyncAction);
public static IObservable<T> DoOnSubscribe<T>(this IObservable<T> source, Action action);
public static IObservable<T> DoOnDispose<T>(this IObservable<T> source, Action disposeAction);
public static IObservable<TOut> WhereSelect<T, TOut>(this IObservable<T> source, Func<T, bool> predicate, Func<T, TOut> selector);
public static IObservable<T> CatchReturn<T>(this IObservable<T> source, T fallback);
public static IObservable<TResult> SelectConstant<T, TResult>(this IObservable<T> source, TResult constant);
public static IObservable<TOut> TrySelect<T, TOut>(this IObservable<T> source, Func<T, TOut> selector);
public static IObservable<TResult> SelectManyThen<T, TMid, TResult>(this IObservable<T> source, Func<T, IObservable<TMid>> first, Func<TMid, IObservable<TResult>> second);
public static IObservable<T> GetMax<T>(this IObservable<T> source, params IObservable<T>[] sources) where T : struct, IComparable<T>;
public static IObservable<T> GetMin<T>(this IObservable<T> source, params IObservable<T>[] sources) where T : struct, IComparable<T>;
public static IObservable<T> SkipWhileNull<T>(this IObservable<T> source) where T : class;
public static IObservable<TSource> CatchIgnore<TSource>(this IObservable<TSource> source);
public static IObservable<T[]> Shuffle<T>(this IObservable<T[]> source);
public static IObservable<bool> Not(this IObservable<bool> source);
public static IObservable<bool> WhereTrue(this IObservable<bool> source);
public static IObservable<bool> WhereFalse(this IObservable<bool> source);
public static IObservable<string> BufferUntil(this IObservable<char> source, char startsWith, char endsWith);
public static IObservable<string> Filter(this IObservable<string> source, string regexPattern);
public static IObservable<string> Filter(this IObservable<string> source, Regex regex);
public static void OnNext<T>(this IObserver<T> observer, params T[] events);
public static IObservable<RxVoid> RunAll(this IReadOnlyList<IObservable<RxVoid>> sources);
public static IObservable<TResult> FirstMatchFromCandidates<TKey, TRaw, TResult>(this IReadOnlyList<TKey> candidates, Func<TKey, IObservable<TRaw>> project, Func<TRaw, TResult> transform, Func<TResult, bool> predicate, TResult fallback);
public static IDisposable ScheduleSafe(this ISequencer scheduler, Action action);
public static IDisposable ScheduleSafe(this ISequencer scheduler, TimeSpan dueTime, Action action);
public static IObservable<RxVoid> Using<T>(this T obj, Action<T> action) where T : IDisposable;
public static IObservable<RxVoid> Using<T>(this T obj, Action<T> action, ISequencer scheduler) where T : IDisposable;
public static IObservable<TResult> Using<T, TResult>(this T obj, Func<T, TResult> function) where T : IDisposable;
public static IObservable<TResult> Using<T, TResult>(this T obj, Func<T, TResult> function, ISequencer scheduler) where T : IDisposable;
public static IObservable<TProperty> ToPropertyObservable<T, TProperty>(this T source, Expression<Func<T, TProperty>> propertyExpression) where T : INotifyPropertyChanged;
public static IObservable<T> ScheduleValue<T>(this T value, TimeSpan dueTime, ISequencer scheduler);
public static IObservable<T> ScheduleValue<T>(this T value, DateTimeOffset dueTime, ISequencer scheduler);
public static IObservable<T> ScheduleValue<T>(this T value, TimeSpan dueTime, ISequencer scheduler, Action<T> action);
public static IObservable<T> ScheduleValue<T>(this T value, DateTimeOffset dueTime, ISequencer scheduler, Action<T> action);
public static IObservable<T> ScheduleValue<T>(this T value, ISequencer scheduler, Func<T, T> function);
public static IObservable<T> ScheduleValue<T>(this T value, TimeSpan dueTime, ISequencer scheduler, Func<T, T> function);
public static IObservable<DateTime> SyncTimer(this TimeSpan timeSpan);
public static IObservable<DateTime> SyncTimer(this TimeSpan timeSpan, ISequencer scheduler);
public static IObservable<TResult> Start<[System.Runtime.CompilerServices.Nullable(2)] TResult>(Func<TResult> function, ISequencer scheduler);
public static (IObservable<T> Observable, IObserver<T> Observer) ToReadOnlyBehavior<[System.Runtime.CompilerServices.Nullable(2)] T>(T initialValue);
public static IObservable<T> OnErrorRetry<T>(this IObservable<T> source);
public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError) where TException : Exception;
public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, TimeSpan delay) where TException : Exception;
public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, int retryCount) where TException : Exception;
public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, int retryCount, TimeSpan delay) where TException : Exception;
public static IObservable<T> OnErrorRetry<T, TException>(this IObservable<T> source, Action<TException> onError, int retryCount, TimeSpan delay, ISequencer delayScheduler) where TException : Exception;
public static IObservable<T> RetryWithBackoff<T>(this IObservable<T> source, int maxRetries, TimeSpan initialDelay);
public static IObservable<T> RetryWithBackoff<T>(this IObservable<T> source, int maxRetries, TimeSpan initialDelay, double backoffFactor, TimeSpan? maxDelay, ISequencer scheduler);
public static IObservable<T> RetryWithDelay<T>(this IObservable<T> source, int retryCount, Func<int, TimeSpan> delaySelector);
public static IObservable<T> RetryForeverWithDelay<T>(this IObservable<T> source, TimeSpan delay);
public static IObservable<T> RetryWithFixedDelay<T>(this IObservable<T> source, int retryCount, TimeSpan delay);
}
}