ApiApprovalTests.Primitives.DotNet8_0.verified.txt

[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Async.Tests")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor.Tests")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Tests")]
namespace ReactiveUI.Primitives
{
    public sealed class AllPredicateObserver<T> : ReactiveUI.Primitives.BooleanTerminalObserver<T>
    {
        public AllPredicateObserver(System.IObserver<bool> observer, System.Func<T, bool> predicate) { }
        public override void OnCompleted() { }
        public override void OnNext(T value) { }
    }
    public sealed class AnyObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public AnyObserver(System.IObserver<bool> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class AnyPredicateObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public AnyPredicateObserver(System.IObserver<bool> observer, System.Func<T, bool> predicate) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class AppendDelegateObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public AppendDelegateObserver(System.Action<T> onNext, System.Action<System.Exception> onError, System.Action onCompleted, T value) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class AppendObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public AppendObserver(System.IObserver<T> observer, T value) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public abstract class BooleanTerminalObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        protected BooleanTerminalObserver(System.IObserver<bool> observer) { }
        protected bool IsDone { get; }
        protected void EmitCompleted(bool value) { }
        public override void OnError(System.Exception error) { }
    }
    public sealed class BufferObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public BufferObserver(System.IObserver<System.Collections.Generic.IList<T>> observer, int count, int skip) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class CollectArrayObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public CollectArrayObserver(System.IObserver<T[]> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class CollectListObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public CollectListObserver(System.IObserver<System.Collections.Generic.IList<T>> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public static class ConnectableSignalMixins
    {
        public static System.IObservable<T> AutoConnect<T>(this ReactiveUI.Primitives.ConnectableSignal<T> source) { }
        public static System.IObservable<T> AutoConnect<T>(this ReactiveUI.Primitives.ConnectableSignal<T> source, int subscriberCount) { }
        public static System.IObservable<T> AutoShare<T>(this ReactiveUI.Primitives.ConnectableSignal<T> source) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> Multicast<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Signals.ISignal<T> hub) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> Replay<T>(this System.IObservable<T> source, int bufferSize) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> Replay<T>(this System.IObservable<T> source, int bufferSize, System.TimeSpan window) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> ReplayLive<T>(this System.IObservable<T> source, int bufferSize) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> ReplayLive<T>(this System.IObservable<T> source, int bufferSize, System.TimeSpan window) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> Share<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> ShareLatest<T>(this System.IObservable<T> source) { }
        public static ReactiveUI.Primitives.ConnectableSignal<T> ShareLive<T>(this System.IObservable<T> source) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class ConnectableSignal<T> : System.IObservable<T>
    {
        public ConnectableSignal(System.IObservable<T> source, ReactiveUI.Primitives.Signals.ISignal<T> hub) { }
        public System.IDisposable Connect() { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    public sealed class ContainsObserver<T> : ReactiveUI.Primitives.BooleanTerminalObserver<T>
    {
        public ContainsObserver(System.IObserver<bool> observer, T value, System.Collections.Generic.IEqualityComparer<T> comparer) { }
        public override void OnCompleted() { }
        public override void OnNext(T value) { }
    }
    public sealed class CountObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public CountObserver(System.IObserver<int> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class CountPredicateObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public CountPredicateObserver(System.IObserver<int> observer, System.Func<T, bool> predicate) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class DefaultIfEmptyObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public DefaultIfEmptyObserver(System.IObserver<T> observer, T defaultValue) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class DisposedMarker : System.IDisposable
    {
        public DisposedMarker() { }
        public void Dispose() { }
    }
    public sealed class DistinctByCountObserver<T, TKey> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public DistinctByCountObserver(System.IObserver<int> observer, System.Func<T, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class DistinctByLongCountObserver<T, TKey> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public DistinctByLongCountObserver(System.IObserver<long> observer, System.Func<T, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class DistinctByObserver<T, TKey> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public DistinctByObserver(System.IObserver<T> observer, System.Func<T, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class DistinctObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public DistinctObserver(System.IObserver<T> observer, System.Collections.Generic.HashSet<T> seen) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class FoldObserver<TSource, TAccumulate> : ReactiveUI.Primitives.SingleSourceObserver<TSource>
    {
        public FoldObserver(System.IObserver<TAccumulate> observer, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(TSource value) { }
    }
    public sealed class IgnoreValuesObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public IgnoreValuesObserver(System.IObserver<T> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class KeepNotNullObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T?>
        where T :  class
    {
        public KeepNotNullObserver(System.IObserver<T> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T? value) { }
    }
    public sealed class KeepTypeObserver<TResult> : ReactiveUI.Primitives.SingleSourceObserver<object?>
    {
        public KeepTypeObserver(System.IObserver<TResult> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(object? value) { }
    }
    public static class LinqMixins
    {
        public static System.IObservable<bool> All<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.IObservable<bool> Any<T>(this System.IObservable<T> source) { }
        public static System.IObservable<bool> Any<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.Threading.Tasks.Task<bool> AnyAsync<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<bool> AnyAsync<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.Threading.Tasks.Task<bool> AnyAsync<T>(this System.IObservable<T> source, System.Threading.CancellationToken cancellationToken) { }
        public static System.Threading.Tasks.Task<bool> AnyAsync<T>(this System.IObservable<T> source, System.Func<T, bool> predicate, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<T> Append<T>(this System.IObservable<T> source, T value) { }
        public static System.IObservable<T> AsObservable<T>(this System.IObservable<T> source) { }
        public static System.IObservable<TResult> Bind<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TResult>> selector) { }
        public static System.IObservable<T> Blend<T>(this System.IObservable<System.IObservable<T>> sources) { }
        public static System.IObservable<T> BlendUnique<T>(params System.IObservable<T>[] sources) { }
        public static System.IObservable<T> BlendUnique<T>(System.IObservable<T>[] sources, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
        public static System.IObservable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.IObservable<TSource> source, int count) { }
        public static System.IObservable<System.Collections.Generic.IList<TSource>> Buffer<TSource>(this System.IObservable<TSource> source, int count, int skip) { }
        public static System.IObservable<T> Calm<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
        public static System.IObservable<T> Calm<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<TResult> CastTo<TResult>(this System.IObservable<object?> source) { }
        public static System.IObservable<T> Chain<T>(this System.IObservable<System.IObservable<T>> sources) { }
        public static System.IObservable<T> Chain<T>(this System.IObservable<T> first, System.IObservable<T> second) { }
        public static System.IObservable<T[]> CollectArray<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T[]> CollectArrayAsync<T>(this System.IObservable<T> source) { }
        public static System.IObservable<System.Collections.Generic.IList<T>> CollectList<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<System.Collections.Generic.IList<T>> CollectListAsync<T>(this System.IObservable<T> source) { }
        public static System.IObservable<bool> Contains<T>(this System.IObservable<T> source, T value) { }
        public static System.IObservable<bool> Contains<T>(this System.IObservable<T> source, T value, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
        public static System.IObservable<int> Count<T>(this System.IObservable<T> source) { }
        public static System.IObservable<int> Count<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.Threading.Tasks.Task<int> CountAsync<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<int> CountAsync<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.Threading.Tasks.Task<int> CountAsync<T>(this System.IObservable<T> source, System.Threading.CancellationToken cancellationToken) { }
        public static System.Threading.Tasks.Task<int> CountAsync<T>(this System.IObservable<T> source, System.Func<T, bool> predicate, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<T> DefaultIfEmpty<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> DefaultIfEmpty<T>(this System.IObservable<T> source, T defaultValue) { }
        public static System.IObservable<T> DelayStart<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
        public static System.IObservable<T> DelayStart<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<T> DelaySubscription<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
        public static System.IObservable<T> DelaySubscription<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static ReactiveUI.Primitives.Disposables.SingleDisposable DisposeWith(this System.IDisposable disposable) { }
        public static System.IDisposable DisposeWith(this System.IDisposable disposable, ReactiveUI.Primitives.Disposables.MultipleDisposable disposables) { }
        public static ReactiveUI.Primitives.Disposables.SingleDisposable DisposeWith(this System.IDisposable disposable, System.Action? action) { }
        public static System.IObservable<T> Distinct<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> Distinct<T>(this System.IObservable<T> source, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
        public static System.IObservable<T> DistinctBy<T, TKey>(this System.IObservable<T> source, System.Func<T, TKey> keySelector) { }
        public static System.IObservable<T> DistinctBy<T, TKey>(this System.IObservable<T> source, System.Func<T, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
        public static System.IObservable<T> Expire<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
        public static System.IObservable<T> Expire<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.Threading.Tasks.Task<T> FirstAsync<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T> FirstOrDefaultAsync<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T> FirstOrDefaultAsync<T>(this System.IObservable<T> source, T defaultValue) { }
        public static System.IObservable<TResult> FlatMap<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TResult>> selector) { }
        public static System.IObservable<TResult> FlatMap<TSource, TCollection, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { }
        public static System.IObservable<TAccumulate> Fold<TSource, TAccumulate>(this System.IObservable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
        public static System.IObservable<TResult> ForkJoin<TLeft, TRight, TResult>(this System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<TResult> FuseLatest<TLeft, TRight, TResult>(this System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<T> IgnoreValues<T>(this System.IObservable<T> source) { }
        public static System.IObservable<bool> IsEmpty<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> Keep<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.IObservable<T> KeepNotNull<T>(this System.IObservable<T?> source)
            where T :  class { }
        public static System.IObservable<TResult> KeepType<TResult>(this System.IObservable<object?> source) { }
        public static System.IObservable<T> KeepWith<T, TState>(this System.IObservable<T> source, TState state, System.Func<TState, T, bool> predicate) { }
        public static System.Threading.Tasks.Task<T> LastAsync<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T> LastOrDefaultAsync<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T> LastOrDefaultAsync<T>(this System.IObservable<T> source, T defaultValue) { }
        public static System.IObservable<TResult> Latch<TLeft, TRight, TResult>(this System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<T> Lead<T>(this System.IObservable<T> source, T value) { }
        public static System.IObservable<long> LongCount<T>(this System.IObservable<T> source) { }
        public static System.IObservable<long> LongCount<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.IObservable<TResult> Map<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, TResult> selector) { }
        public static System.IObservable<TResult> MapWith<TSource, TState, TResult>(this System.IObservable<TSource> source, TState state, System.Func<TState, TSource, TResult> selector) { }
        public static System.IObservable<T> ObserveOn<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<TResult> Pair<TLeft, TRight, TResult>(this System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<TResult> PairLatest<TLeft, TRight, TResult>(this System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<T> Prepend<T>(this System.IObservable<T> source, System.Collections.Generic.IEnumerable<T> values) { }
        public static System.IObservable<T> Prepend<T>(this System.IObservable<T> source, T value) { }
        public static System.IObservable<T> Prepend<T>(this System.IObservable<T> source, params T[] values) { }
        public static System.IObservable<T> Probe<T>(this System.IObservable<T> source, System.TimeSpan period) { }
        public static System.IObservable<T> Probe<T>(this System.IObservable<T> source, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<T> Race<T>(this System.IObservable<System.IObservable<T>> sources) { }
        public static System.IObservable<T> Reattempt<T>(this System.IObservable<T> source, int retryCount) { }
        public static System.IObservable<T> Recover<T>(this System.IObservable<T> source, System.Func<System.Exception, System.IObservable<T>> handler) { }
        public static System.IObservable<TAccumulate> Reduce<TSource, TAccumulate>(this System.IObservable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
        public static System.IObservable<T> Rescue<T>(this System.IObservable<T> source, System.Func<System.Exception, System.IObservable<T>> handler) { }
        public static System.IObservable<T> Resume<T>(this System.IObservable<T> source, System.IObservable<T> fallback) { }
        public static System.IObservable<T> Shift<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
        public static System.IObservable<T> Shift<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<T> Skip<T>(this System.IObservable<T> source, int count) { }
        public static System.IObservable<T> SkipWhile<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.Spark<T>> Spark<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> Stabilize<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
        public static System.IObservable<T> Stabilize<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<T> SubscribeOn<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> SwitchTo<T>(this System.IObservable<System.IObservable<T>> sources) { }
        public static System.IObservable<TResult> SyncLatest<TLeft, TRight, TResult>(this System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<T> Take<T>(this System.IObservable<T> source, int count) { }
        public static System.IObservable<T> TakeWhile<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public static System.IObservable<T> Tap<T>(this System.IObservable<T> source, System.Action<T> onNext) { }
        public static System.IObservable<T> Tap<T>(this System.IObservable<T> source, System.Action<T> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
        public static System.IObservable<T> TapWith<T, TState>(this System.IObservable<T> source, TState state, System.Action<TState, T> onNext) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.TimeInterval<T>> TimeInterval<T>(this System.IObservable<T> source) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.TimeInterval<T>> TimeInterval<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.Moment<T>> Timestamp<T>(this System.IObservable<T> source) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.Moment<T>> Timestamp<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static System.IObservable<T[]> ToArray<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T[]> ToArrayAsync<T>(this System.IObservable<T> source) { }
        public static System.IObservable<System.Collections.Generic.IList<T>> ToList<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<System.Collections.Generic.IList<T>> ToListAsync<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> ToObservable<T>(this System.Collections.Generic.IEnumerable<T> values) { }
        public static System.IObservable<T> ToObservable<T>(this System.Collections.Generic.IEnumerable<T> values, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<T> ToSignal<T>(this System.Collections.Generic.IEnumerable<T> values) { }
        public static System.IObservable<T> ToSignal<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> ToSignal<T>(this System.Collections.Generic.IEnumerable<T> values, System.Threading.CancellationToken cancellationToken) { }
        public static System.Threading.Tasks.Task<T> ToTask<T>(this System.IObservable<T> source) { }
        public static System.Threading.Tasks.Task<T> ToTask<T>(this System.Threading.Tasks.Task<T> task) { }
        public static System.Threading.Tasks.Task<T> ToTask<T>(this System.IObservable<T> source, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<T> Unique<T>(this System.IObservable<T> source) { }
        public static System.IObservable<T> Unique<T>(this System.IObservable<T> source, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
        public static System.IObservable<T> UniqueBy<T, TKey>(this System.IObservable<T> source, System.Func<T, TKey> keySelector) { }
        public static System.IObservable<T> UniqueBy<T, TKey>(this System.IObservable<T> source, System.Func<T, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
        public static System.IObservable<T> Unspark<T>(this System.IObservable<ReactiveUI.Primitives.Core.Spark<T>> source) { }
    }
    public sealed class LongCountObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public LongCountObserver(System.IObserver<long> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class LongCountPredicateObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public LongCountPredicateObserver(System.IObserver<long> observer, System.Func<T, bool> predicate) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class ReduceObserver<TSource, TAccumulate> : ReactiveUI.Primitives.SingleSourceObserver<TSource>
    {
        public ReduceObserver(System.IObserver<TAccumulate> observer, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(TSource value) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    [System.Serializable]
    public readonly struct RxVoid : System.IEquatable<ReactiveUI.Primitives.RxVoid>
    {
        public static ReactiveUI.Primitives.RxVoid Default { get; }
        public bool Equals(ReactiveUI.Primitives.RxVoid other) { }
        public override bool Equals(object? obj) { }
        public override int GetHashCode() { }
        public override string ToString() { }
        public static bool operator !=(ReactiveUI.Primitives.RxVoid first, ReactiveUI.Primitives.RxVoid second) { }
        public static bool operator ==(ReactiveUI.Primitives.RxVoid first, ReactiveUI.Primitives.RxVoid second) { }
    }
    public abstract class SingleSourceObserver<T> : System.IDisposable, System.IObserver<T>
    {
        protected SingleSourceObserver() { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public abstract void OnCompleted();
        public abstract void OnError(System.Exception error);
        public abstract void OnNext(T value);
        public void SetSubscription(System.IDisposable subscription) { }
    }
    public sealed class SkipObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public SkipObserver(System.IObserver<T> observer, int count) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class SkipWhileObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public SkipWhileObserver(System.IObserver<T> observer, System.Func<T, bool> predicate) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class SparkObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public SparkObserver(System.IObserver<ReactiveUI.Primitives.Core.Spark<T>> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public static class SubscribeMixins
    {
        public static void Rethrow(this System.Exception? exception) { }
        public static System.IDisposable Subscribe<T>(this System.IObservable<T> source) { }
        public static System.IDisposable Subscribe<T>(this System.IObservable<T> source, System.Action<T> onNext) { }
        public static System.IDisposable Subscribe<T>(this System.IObservable<T> source, System.Action<T> onNext, System.Action onCompleted) { }
        public static System.IDisposable Subscribe<T>(this System.IObservable<T> source, System.Action<T> onNext, System.Action<System.Exception> onError) { }
        public static System.IDisposable Subscribe<T>(this System.IObservable<T> source, System.Action<T> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
    }
    public sealed class TakeObserver<T> : System.IDisposable, System.IObserver<T>
    {
        public TakeObserver(System.IObserver<T> observer, int count) { }
        public void Dispose() { }
        public void OnCompleted() { }
        public void OnError(System.Exception error) { }
        public void OnNext(T value) { }
        public void SetSubscription(System.IDisposable subscription) { }
    }
    public sealed class TakeWhileObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public TakeWhileObserver(System.IObserver<T> observer, System.Func<T, bool> predicate) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class TapObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public TapObserver(System.IObserver<T> observer, System.Action<T> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class TimeIntervalObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public TimeIntervalObserver(System.IObserver<ReactiveUI.Primitives.Core.TimeInterval<T>> observer, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class UniqueByObserver<T, TKey> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public UniqueByObserver(System.IObserver<T> observer, System.Func<T, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class UniqueObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<T>
    {
        public UniqueObserver(System.IObserver<T> observer, System.Collections.Generic.IEqualityComparer<T> comparer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(T value) { }
    }
    public sealed class UnsparkObserver<T> : ReactiveUI.Primitives.SingleSourceObserver<ReactiveUI.Primitives.Core.Spark<T>>
    {
        public UnsparkObserver(System.IObserver<T> observer) { }
        public override void OnCompleted() { }
        public override void OnError(System.Exception error) { }
        public override void OnNext(ReactiveUI.Primitives.Core.Spark<T> spark) { }
    }
}
namespace ReactiveUI.Primitives.Concurrency
{
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
    {
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
        public static bool IsScheduleRequired { get; }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public System.IDisposable Schedule(System.Action action) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
    }
    public abstract class DispatchSequencerBase : ReactiveUI.Primitives.Concurrency.ISequencer
    {
        protected DispatchSequencerBase() { }
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        protected abstract bool Post(System.Action drain);
        protected void PostDrain() { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
        protected virtual void ScheduleDelayed(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
        protected static System.TimeSpan DelayUntil(long dueTimestamp) { }
        protected static void RunIfActive(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
    }
    public interface IScheduledItem<out TAbsolute>
    {
        TAbsolute DueTime { get; }
        void Invoke();
    }
    public interface ISequencer
    {
        System.DateTimeOffset Now { get; }
        long Timestamp { get; }
        void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item);
        void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp);
    }
    public interface IStopwatch
    {
        System.TimeSpan Elapsed { get; }
    }
    public interface IStopwatchProvider
    {
        ReactiveUI.Primitives.Concurrency.IStopwatch StartStopwatch();
    }
    public interface IWorkItem
    {
        void Execute();
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
    {
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public System.IDisposable Schedule(System.Action action) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public abstract class ScheduledItem<TAbsolute> : ReactiveUI.Primitives.Concurrency.IScheduledItem<TAbsolute>, ReactiveUI.Primitives.Disposables.IsDisposed, System.IComparable, System.IComparable<ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>>, System.IDisposable
        where TAbsolute : System.IComparable<TAbsolute>
    {
        protected ScheduledItem(TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) { }
        public TAbsolute DueTime { get; }
        public bool IsDisposed { get; }
        public void Cancel() { }
        public int CompareTo(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>? other) { }
        public int CompareTo(object? obj) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public override bool Equals(object? obj) { }
        public override int GetHashCode() { }
        public void Invoke() { }
        protected abstract System.IDisposable InvokeCore();
        public static bool operator !=(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>? left, ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>? right) { }
        public static bool operator <(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> left, ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> right) { }
        public static bool operator <=(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> left, ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> right) { }
        public static bool operator ==(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>? left, ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>? right) { }
        public static bool operator >(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> left, ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> right) { }
        public static bool operator >=(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> left, ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> right) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class ScheduledItem<TAbsolute, TValue> : ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute>
        where TAbsolute : System.IComparable<TAbsolute>
    {
        public ScheduledItem(ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TValue state, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TValue, System.IDisposable> action, TAbsolute dueTime) { }
        public ScheduledItem(ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TValue state, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) { }
        protected override System.IDisposable InvokeCore() { }
    }
    public static class Sequencer
    {
        public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer CurrentThread { get; }
        public static ReactiveUI.Primitives.Concurrency.ISequencer Default { get; }
        public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Immediate { get; }
        public static System.TimeSpan Normalize(System.TimeSpan timeSpan) { }
        public static System.IDisposable Schedule(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action action) { }
        public static System.IDisposable Schedule(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<System.Action> action) { }
        public static System.IDisposable Schedule(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.DateTimeOffset dueTime, System.Action action) { }
        public static System.IDisposable Schedule(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan dueTime, System.Action action) { }
        public static System.IDisposable Schedule<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, System.Action<TState> action) { }
        public static System.IDisposable Schedule<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public static System.IDisposable Schedule<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, System.DateTimeOffset dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public static System.IDisposable Schedule<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, System.TimeSpan dueTime, System.Action<TState> action) { }
        public static System.IDisposable Schedule<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, System.TimeSpan dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public static System.IDisposable Schedule<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, long dueTimestamp, System.Action<TState> action) { }
        public static System.IDisposable ScheduleAction<TState>(this ReactiveUI.Primitives.Concurrency.ISequencer scheduler, TState state, System.Action<TState> action) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class SequencerQueue<TAbsolute>
        where TAbsolute : System.IComparable<TAbsolute>
    {
        public SequencerQueue() { }
        public SequencerQueue(int capacity) { }
        public int Count { get; }
        public ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Dequeue() { }
        public void Enqueue(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> scheduledItem) { }
        public ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Peek() { }
        public bool Remove(ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> scheduledItem) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
    {
        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
        public System.Threading.SynchronizationContext Context { get; }
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        public static ReactiveUI.Primitives.Concurrency.SynchronizationContextSequencer Current { get; }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
    {
        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
        public static ReactiveUI.Primitives.Concurrency.TaskPoolSequencer Default { get; }
        public static ReactiveUI.Primitives.Concurrency.TaskPoolSequencer Instance { get; }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class TestClock : ReactiveUI.Primitives.Concurrency.VirtualClock
    {
        public TestClock() { }
        public TestClock(System.DateTimeOffset initialClock) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
    {
        public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        public void Dispose() { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class VirtualClock : ReactiveUI.Primitives.Concurrency.VirtualTimeSequencer<System.DateTimeOffset, System.TimeSpan>
    {
        public VirtualClock() { }
        public VirtualClock(System.DateTimeOffset initialClock) { }
        protected override System.DateTimeOffset Add(System.DateTimeOffset absolute, System.TimeSpan relative) { }
        protected override System.DateTimeOffset ToDateTimeOffset(System.DateTimeOffset absolute) { }
        protected override System.TimeSpan ToRelative(System.TimeSpan timeSpan) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public abstract class VirtualTimeSequencerBase<TAbsolute, TRelative> : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
        where TAbsolute : System.IComparable<TAbsolute>
    {
        protected VirtualTimeSequencerBase() { }
        protected VirtualTimeSequencerBase(TAbsolute initialClock, System.Collections.Generic.IComparer<TAbsolute> comparer) { }
        public TAbsolute Clock { get; protected set; }
        protected System.Collections.Generic.IComparer<TAbsolute> Comparer { get; }
        public bool IsEnabled { get; }
        public System.DateTimeOffset Now { get; }
        public long Timestamp { get; }
        protected abstract TAbsolute Add(TAbsolute absolute, TRelative relative);
        public void AdvanceBy(TRelative time) { }
        public void AdvanceTo(TAbsolute time) { }
        protected abstract ReactiveUI.Primitives.Concurrency.IScheduledItem<TAbsolute>? GetNext();
        protected virtual object? GetService(System.Type serviceType) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
        public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
        public System.IDisposable Schedule<TState>(TState state, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public System.IDisposable Schedule<TState>(TState state, System.DateTimeOffset dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public System.IDisposable Schedule<TState>(TState state, System.TimeSpan dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public abstract System.IDisposable ScheduleAbsolute<TState>(TState state, TAbsolute dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action);
        public System.IDisposable ScheduleRelative<TState>(TState state, TRelative dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
        public void Sleep(TRelative time) { }
        public void Start() { }
        public ReactiveUI.Primitives.Concurrency.IStopwatch StartStopwatch() { }
        public void Stop() { }
        protected abstract System.DateTimeOffset ToDateTimeOffset(TAbsolute absolute);
        protected abstract TRelative ToRelative(System.TimeSpan timeSpan);
    }
    public static class VirtualTimeSequencerExtensions
    {
        public static System.IDisposable ScheduleAbsolute<TAbsolute, TRelative>(this ReactiveUI.Primitives.Concurrency.VirtualTimeSequencerBase<TAbsolute, TRelative> scheduler, TAbsolute dueTime, System.Action action)
            where TAbsolute : System.IComparable<TAbsolute> { }
        public static System.IDisposable ScheduleRelative<TAbsolute, TRelative>(this ReactiveUI.Primitives.Concurrency.VirtualTimeSequencerBase<TAbsolute, TRelative> scheduler, TRelative dueTime, System.Action action)
            where TAbsolute : System.IComparable<TAbsolute> { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public abstract class VirtualTimeSequencer<TAbsolute, TRelative> : ReactiveUI.Primitives.Concurrency.VirtualTimeSequencerBase<TAbsolute, TRelative>
        where TAbsolute : System.IComparable<TAbsolute>
    {
        protected VirtualTimeSequencer() { }
        protected VirtualTimeSequencer(TAbsolute initialClock, System.Collections.Generic.IComparer<TAbsolute> comparer) { }
        protected override ReactiveUI.Primitives.Concurrency.IScheduledItem<TAbsolute>? GetNext() { }
        public override System.IDisposable ScheduleAbsolute<TState>(TState state, TAbsolute dueTime, System.Func<ReactiveUI.Primitives.Concurrency.ISequencer, TState, System.IDisposable> action) { }
    }
}
namespace ReactiveUI.Primitives.Core
{
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public readonly struct EventPattern<TEventArgs> : System.IEquatable<ReactiveUI.Primitives.Core.EventPattern<TEventArgs>>
        where TEventArgs : System.EventArgs
    {
        public EventPattern(object? sender, TEventArgs eventArgs) { }
        public TEventArgs EventArgs { get; }
        public object? Sender { get; }
        public bool Equals(ReactiveUI.Primitives.Core.EventPattern<TEventArgs> other) { }
        public override bool Equals(object? obj) { }
        public override int GetHashCode() { }
        public override string ToString() { }
        public static bool operator !=(ReactiveUI.Primitives.Core.EventPattern<TEventArgs> left, ReactiveUI.Primitives.Core.EventPattern<TEventArgs> right) { }
        public static bool operator ==(ReactiveUI.Primitives.Core.EventPattern<TEventArgs> left, ReactiveUI.Primitives.Core.EventPattern<TEventArgs> right) { }
    }
    public interface IObserver<in TValue, out TResult>
    {
        TResult OnCompleted();
        TResult OnError(System.Exception exception);
        TResult OnNext(TValue value);
    }
    public interface IRequireCurrentThread<out T> : System.IObservable<T>
    {
        bool IsRequiredSubscribeOnCurrentThread();
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    [System.Serializable]
    public readonly struct Moment<T> : System.IEquatable<ReactiveUI.Primitives.Core.Moment<T>>
    {
        public Moment(T value, System.DateTimeOffset timestamp) { }
        public System.DateTimeOffset Timestamp { get; }
        public T Value { get; }
        public bool Equals(ReactiveUI.Primitives.Core.Moment<T> other) { }
        public override bool Equals(object? obj) { }
        public override int GetHashCode() { }
        public override string ToString() { }
        public static bool operator !=(ReactiveUI.Primitives.Core.Moment<T> first, ReactiveUI.Primitives.Core.Moment<T> second) { }
        public static bool operator ==(ReactiveUI.Primitives.Core.Moment<T> first, ReactiveUI.Primitives.Core.Moment<T> second) { }
    }
    public static class Spark
    {
        public static ReactiveUI.Primitives.Core.Spark<T> CreateOnCompleted<T>() { }
        public static ReactiveUI.Primitives.Core.Spark<T> CreateOnError<T>(System.Exception error) { }
        public static ReactiveUI.Primitives.Core.Spark<T> CreateOnNext<T>(T value) { }
    }
    public enum SparkKind
    {
        OnNext = 0,
        OnError = 1,
        OnCompleted = 2,
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    [System.Serializable]
    public readonly struct Spark<T> : System.IEquatable<ReactiveUI.Primitives.Core.Spark<T>>
    {
        public System.Exception Exception { get; }
        public bool HasValue { get; }
        public ReactiveUI.Primitives.Core.SparkKind Kind { get; }
        public T Value { get; }
        public void Accept(System.IObserver<T> observer) { }
        public void Accept(System.Action<T> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
        public TResult Accept<TResult>(ReactiveUI.Primitives.Core.IObserver<T, TResult> observer) { }
        public TResult Accept<TResult>(System.Func<T, TResult> onNext, System.Func<System.Exception, TResult> onError, System.Func<TResult> onCompleted) { }
        public bool Equals(ReactiveUI.Primitives.Core.Spark<T> other) { }
        public override bool Equals(object? obj) { }
        public override int GetHashCode() { }
        public System.IObservable<T> ToObservable() { }
        public System.IObservable<T> ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public override string ToString() { }
        public static bool operator !=(ReactiveUI.Primitives.Core.Spark<T> left, ReactiveUI.Primitives.Core.Spark<T> right) { }
        public static bool operator ==(ReactiveUI.Primitives.Core.Spark<T> left, ReactiveUI.Primitives.Core.Spark<T> right) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    [System.Serializable]
    public readonly struct TimeInterval<T> : System.IEquatable<ReactiveUI.Primitives.Core.TimeInterval<T>>
    {
        public TimeInterval(T value, System.TimeSpan interval) { }
        public System.TimeSpan Interval { get; }
        public T Value { get; }
        public bool Equals(ReactiveUI.Primitives.Core.TimeInterval<T> other) { }
        public override bool Equals(object? obj) { }
        public override int GetHashCode() { }
        public override string ToString() { }
        public static bool operator !=(ReactiveUI.Primitives.Core.TimeInterval<T> first, ReactiveUI.Primitives.Core.TimeInterval<T> second) { }
        public static bool operator ==(ReactiveUI.Primitives.Core.TimeInterval<T> first, ReactiveUI.Primitives.Core.TimeInterval<T> second) { }
    }
    public static class Witness
    {
        public static System.IObserver<T> Create<T>(System.Action<T> onNext) { }
        public static System.IObserver<T> Create<T>(System.Action<T> onNext, System.Action onCompleted) { }
        public static System.IObserver<T> Create<T>(System.Action<T> onNext, System.Action<System.Exception> onError) { }
        public static System.IObserver<T> Create<T>(System.Action<T> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
        public static System.IObserver<T> Safe<T>(System.IObserver<T> observer) { }
        public static System.IObserver<T> Safe<T>(System.IObserver<T> observer, System.IDisposable cancel) { }
    }
}
namespace ReactiveUI.Primitives.Disposables
{
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class ActionDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public ActionDisposable(System.Action action) { }
        public bool IsDisposed { get; }
        public void Dispose() { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class AssignmentSlot : ReactiveUI.Primitives.Disposables.SingleDisposable
    {
        public AssignmentSlot() { }
        public AssignmentSlot(System.Action? action) { }
        public AssignmentSlot(System.IDisposable disposable) { }
        public AssignmentSlot(System.IDisposable disposable, System.Action? action) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class BooleanDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public BooleanDisposable() { }
        public bool IsDisposed { get; }
        public void Dispose() { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class CancellationDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public CancellationDisposable() { }
        public CancellationDisposable(System.Threading.CancellationTokenSource cts) { }
        public bool IsDisposed { get; }
        public System.Threading.CancellationToken Token { get; }
        public void Dispose() { }
    }
    public static class Disposable
    {
        public static System.IDisposable Empty { get; }
        public static System.IDisposable Create(System.Action dispose) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class DisposableBag : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public DisposableBag() { }
        public DisposableBag(System.IDisposable first, System.IDisposable second) { }
        public DisposableBag(System.IDisposable first, System.IDisposable second, System.IDisposable third) { }
        public bool IsDisposed { get; }
        public void Add(System.IDisposable disposable) { }
        public void Dispose() { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class EmptyDisposable : System.IDisposable
    {
        public static ReactiveUI.Primitives.Disposables.EmptyDisposable Instance { get; }
        public void Dispose() { }
    }
    public interface IsDisposed : System.IDisposable
    {
        bool IsDisposed { get; }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class MultipleDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public MultipleDisposable() { }
        public MultipleDisposable(params System.IDisposable[] disposables) { }
        public MultipleDisposable(System.IDisposable first, System.IDisposable second) { }
        public MultipleDisposable(System.IDisposable first, System.IDisposable second, System.IDisposable third) { }
        public bool IsDisposed { get; }
        public void Add(System.IDisposable disposable) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public bool Remove(System.IDisposable? item) { }
        public static System.IDisposable Create(params System.IDisposable[] disposables) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class MutableDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public MutableDisposable() { }
        public System.IDisposable? Disposable { get; set; }
        public bool IsDisposed { get; }
        public void Dispose() { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public OnceDisposable() { }
        public System.IDisposable? Disposable { get; set; }
        public bool IsAssigned { get; }
        public bool IsDisposed { get; }
        public void Dispose() { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class Pocket : ReactiveUI.Primitives.Disposables.MultipleDisposable
    {
        public Pocket() { }
        public Pocket(params System.IDisposable[] disposables) { }
        public Pocket(System.IDisposable first, System.IDisposable second) { }
        public Pocket(System.IDisposable first, System.IDisposable second, System.IDisposable third) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class SingleDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public SingleDisposable() { }
        public SingleDisposable(System.Action? action) { }
        public SingleDisposable(System.IDisposable disposable) { }
        public SingleDisposable(System.IDisposable disposable, System.Action? action) { }
        public bool IsDisposed { get; }
        public void Create(System.IDisposable disposable) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class SingleReplaceableDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public SingleReplaceableDisposable() { }
        public SingleReplaceableDisposable(System.Action? action) { }
        public SingleReplaceableDisposable(System.IDisposable disposable) { }
        public SingleReplaceableDisposable(System.IDisposable disposable, System.Action? action) { }
        public bool IsDisposed { get; }
        public void Create(System.IDisposable disposable) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class Slot : ReactiveUI.Primitives.Disposables.SingleReplaceableDisposable
    {
        public Slot() { }
        public Slot(System.Action? action) { }
        public Slot(System.IDisposable disposable) { }
        public Slot(System.IDisposable disposable, System.Action? action) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class SwapDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
    {
        public SwapDisposable() { }
        public System.IDisposable? Disposable { get; set; }
        public bool IsDisposed { get; }
        public void Dispose() { }
    }
}
namespace ReactiveUI.Primitives.Signals
{
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class AsyncSignal<T> : ReactiveUI.Primitives.Disposables.IsDisposed, ReactiveUI.Primitives.Signals.IAwaitSignal<T>, ReactiveUI.Primitives.Signals.ISignal<T>, ReactiveUI.Primitives.Signals.ISignal<T, T>, System.IDisposable, System.IObservable<T>, System.IObserver<T>, System.Runtime.CompilerServices.INotifyCompletion
    {
        public AsyncSignal() { }
        public bool HasObservers { get; }
        public bool IsCompleted { get; }
        public bool IsDisposed { get; }
        public T Value { get; }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public ReactiveUI.Primitives.Signals.IAwaitSignal<T> GetAwaiter() { }
        public T GetResult() { }
        public void OnCompleted() { }
        public void OnCompleted(System.Action continuation) { }
        public void OnError(System.Exception error) { }
        public void OnNext(T value) { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    public sealed class AwaitObserver<T> : System.IObserver<T>
    {
        public AwaitObserver(System.Action callback, bool originalContext) { }
        public void OnCompleted() { }
        public void OnError(System.Exception error) { }
        public void OnNext(T value) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class BehaviorSignal<T> : ReactiveUI.Primitives.Disposables.IsDisposed, ReactiveUI.Primitives.Signals.ISignal<T>, ReactiveUI.Primitives.Signals.ISignal<T, T>, System.IDisposable, System.IObservable<T>, System.IObserver<T>
    {
        public BehaviorSignal(T defaultValue) { }
        public bool HasObservers { get; }
        public bool IsDisposed { get; }
        public T Value { get; }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public void OnCompleted() { }
        public void OnError(System.Exception error) { }
        public void OnNext(T value) { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
        public bool TryGetValue(out T? value) { }
    }
    public readonly struct CommandExecution<TResult> : System.IEquatable<ReactiveUI.Primitives.Signals.CommandExecution<TResult>>
    {
        public ReactiveUI.Primitives.Signals.CommandExecution<TResult> ConfigureAwait(bool continueOnCapturedContext) { }
        public ReactiveUI.Primitives.Signals.CommandExecution<TResult>.Awaiter GetAwaiter() { }
        public readonly struct Awaiter : System.IEquatable<ReactiveUI.Primitives.Signals.CommandExecution<TResult>.Awaiter>, System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion
        {
            public bool IsCompleted { get; }
            public TResult GetResult() { }
            public void OnCompleted(System.Action continuation) { }
            public void UnsafeOnCompleted(System.Action continuation) { }
        }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class CommandSignal<TResult> : System.IDisposable, System.IObservable<TResult>
    {
        public CommandSignal(System.Func<TResult> execute) { }
        public CommandSignal(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute) { }
        public CommandSignal(System.Func<TResult> execute, System.IObservable<bool>? canRun) { }
        public CommandSignal(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canRun) { }
        public bool CanRun { get; }
        public System.IObservable<System.Exception> Faults { get; }
        public ReactiveUI.Primitives.Signals.StateSignal<bool> IsRunning { get; }
        public System.IObservable<TResult> Results { get; }
        public void Dispose() { }
        public ReactiveUI.Primitives.Signals.CommandExecution<TResult> ExecuteAsync() { }
        public ReactiveUI.Primitives.Signals.CommandExecution<TResult> ExecuteAsync(System.Threading.CancellationToken cancellationToken) { }
        public System.IDisposable Subscribe(System.IObserver<TResult> observer) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class FinalSignal<T> : ReactiveUI.Primitives.Signals.AsyncSignal<T>
    {
        public FinalSignal() { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class HistorySignal<T> : ReactiveUI.Primitives.Signals.ReplaySignal<T>
    {
        public HistorySignal() { }
        public HistorySignal(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public HistorySignal(System.TimeSpan window) { }
        public HistorySignal(int bufferSize) { }
        public HistorySignal(System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public HistorySignal(int bufferSize, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public HistorySignal(int bufferSize, System.TimeSpan window) { }
        public HistorySignal(int bufferSize, System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
    }
    public interface IAwaitSignal<T> : ReactiveUI.Primitives.Disposables.IsDisposed, ReactiveUI.Primitives.Signals.ISignal<T>, ReactiveUI.Primitives.Signals.ISignal<T, T>, System.IDisposable, System.IObservable<T>, System.IObserver<T>, System.Runtime.CompilerServices.INotifyCompletion
    {
        bool IsCompleted { get; }
        ReactiveUI.Primitives.Signals.IAwaitSignal<T> GetAwaiter();
        T GetResult();
    }
    public interface ISignal<T> : ReactiveUI.Primitives.Disposables.IsDisposed, ReactiveUI.Primitives.Signals.ISignal<T, T>, System.IDisposable, System.IObservable<T>, System.IObserver<T> { }
    public interface ISignal<in TSource, out TResult> : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable, System.IObservable<TResult>, System.IObserver<TSource>
    {
        bool HasObservers { get; }
    }
    public interface ITaskSignal<out T> : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable, System.IObservable<T>
    {
        System.Threading.CancellationTokenSource? CancellationTokenSource { get; }
        bool IsCancellationRequested { get; }
        System.IObservable<T>? Source { get; }
        void GetOperationCanceled(System.IObserver<System.Exception> observer);
    }
    public sealed class KeepSignal<T> : ReactiveUI.Primitives.Core.IRequireCurrentThread<T>, System.IObservable<T>
    {
        public KeepSignal(System.IObservable<T> source, System.Func<T, bool> predicate) { }
        public bool IsRequiredSubscribeOnCurrentThread() { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    public sealed class MapSignal<TSource, TResult> : ReactiveUI.Primitives.Core.IRequireCurrentThread<TResult>, System.IObservable<TResult>
    {
        public MapSignal(System.IObservable<TSource> source, System.Func<TSource, TResult> selector) { }
        public bool IsRequiredSubscribeOnCurrentThread() { }
        public System.IDisposable Subscribe(System.IObserver<TResult> observer) { }
    }
    public sealed class ObserverHandler<T> : System.IDisposable
    {
        public ObserverHandler(ReactiveUI.Primitives.Signals.AsyncSignal<T> subject, System.IObserver<T> observer) { }
        public void Dispose() { }
    }
    [System.Diagnostics.DebuggerDisplay("{Value}")]
    public sealed class ProjectedReadOnlyState<TSource, TResult> : System.IDisposable, System.IObservable<TResult>, System.IObserver<TSource>
    {
        public System.IObservable<TResult> Changed { get; }
        public TResult Value { get; }
        public void Dispose() { }
        public void OnCompleted() { }
        public void OnError(System.Exception error) { }
        public void OnNext(TSource value) { }
        public System.IDisposable Subscribe(System.IObserver<TResult> observer) { }
        public static ReactiveUI.Primitives.Signals.ProjectedReadOnlyState<TSource, TResult> Create(ReactiveUI.Primitives.Signals.StateSignal<TSource> source, System.Func<TSource, TResult> selector) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public sealed class ReadOnlyState<T> : System.IDisposable, System.IObservable<T>
    {
        public ReadOnlyState(System.IObservable<T> source, T initialValue) { }
        public System.IObservable<T> Changed { get; }
        public T Value { get; }
        public void Dispose() { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class ReplaySignal<T> : ReactiveUI.Primitives.Disposables.IsDisposed, ReactiveUI.Primitives.Signals.ISignal<T>, ReactiveUI.Primitives.Signals.ISignal<T, T>, System.IDisposable, System.IObservable<T>, System.IObserver<T>
    {
        public ReplaySignal() { }
        public ReplaySignal(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public ReplaySignal(System.TimeSpan window) { }
        public ReplaySignal(int bufferSize) { }
        public ReplaySignal(System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public ReplaySignal(int bufferSize, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public ReplaySignal(int bufferSize, System.TimeSpan window) { }
        public ReplaySignal(int bufferSize, System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public bool HasObservers { get; }
        public bool IsDisposed { get; }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public void OnCompleted() { }
        public void OnError(System.Exception exception) { }
        public void OnNext(T value) { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    public static class Signal
    {
        public static System.IObservable<long> After(System.DateTimeOffset dueTime) { }
        public static System.IObservable<long> After(System.TimeSpan dueTime) { }
        public static System.IObservable<long> After(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<long> After(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<long> After(System.TimeSpan dueTime, System.TimeSpan period) { }
        public static System.IObservable<long> After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> Blend<T>(params System.IObservable<T>[] sources) { }
        public static System.IObservable<T> Chain<T>(params System.IObservable<T>[] sources) { }
        public static System.IObservable<T> Create<T>(System.Func<System.IObserver<T>, System.IDisposable> subscribe) { }
        public static System.IObservable<T> Create<T>(System.Func<System.IObserver<T>, System.IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread) { }
        public static System.IObservable<T> CreateSafe<T>(System.Func<System.IObserver<T>, System.IDisposable> subscribe) { }
        public static System.IObservable<T> CreateSafe<T>(System.Func<System.IObserver<T>, System.IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread) { }
        public static System.IObservable<T> CreateWithState<T, TState>(TState state, System.Func<TState, System.IObserver<T>, System.IDisposable> subscribe) { }
        public static System.IObservable<T> CreateWithState<T, TState>(TState state, System.Func<TState, System.IObserver<T>, System.IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread) { }
        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Emit(ReactiveUI.Primitives.RxVoid value) { }
        public static System.IObservable<bool> Emit(bool value) { }
        public static System.IObservable<int> Emit(int value) { }
        public static System.IObservable<T> Emit<T>(T value) { }
        public static System.IObservable<T> Emit<T>(T value, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<ReactiveUI.Primitives.RxVoid> EmitRxVoid() { }
        public static System.IObservable<long> Every(System.TimeSpan period) { }
        public static System.IObservable<long> Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> Fail<T>(System.Exception error) { }
        public static System.IObservable<T> Fail<T>(System.Exception error, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> Fail<T>(System.Exception error, T witness) { }
        public static System.IObservable<T> Fail<T>(System.Exception error, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, T witness) { }
        public static System.IObservable<TResult> ForkJoin<TLeft, TRight, TResult>(System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<T> FromAsync<T>(System.Func<System.Threading.Tasks.Task<T>> taskFactory) { }
        public static System.IObservable<T> FromAsync<T>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<T>> taskFactory) { }
        public static System.IObservable<T> FromAsync<T>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<T>> taskFactory, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<T> FromAsyncEnumerable<T>(System.Collections.Generic.IAsyncEnumerable<T> values) { }
        public static System.IObservable<T> FromAsyncEnumerable<T>(System.Collections.Generic.IAsyncEnumerable<T> values, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<T> FromEnumerable<T>(System.Collections.Generic.IEnumerable<T> values) { }
        public static System.IObservable<T> FromEnumerable<T>(System.Collections.Generic.IEnumerable<T> values, System.Threading.CancellationToken cancellationToken) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.EventPattern<System.EventArgs>> FromEventPattern(System.Action<System.EventHandler> addHandler, System.Action<System.EventHandler> removeHandler) { }
        public static System.IObservable<ReactiveUI.Primitives.Core.EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(System.Action<System.EventHandler<TEventArgs>> addHandler, System.Action<System.EventHandler<TEventArgs>> removeHandler)
            where TEventArgs : System.EventArgs { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<ReactiveUI.Primitives.RxVoid> FromTask(System.Func<System.Threading.CancellationTokenSource, System.Threading.Tasks.Task<ReactiveUI.Primitives.RxVoid>> execution) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<ReactiveUI.Primitives.RxVoid> FromTask(System.Func<System.Threading.CancellationTokenSource, System.Threading.Tasks.Task<ReactiveUI.Primitives.RxVoid>> execution, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<ReactiveUI.Primitives.RxVoid> FromTask(System.Func<System.Threading.CancellationTokenSource, System.Threading.Tasks.Task<ReactiveUI.Primitives.RxVoid>> execution, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<TResult> FromTask<TResult>(System.Func<System.Threading.CancellationTokenSource, System.Threading.Tasks.Task<TResult>> actionAsync) { }
        public static System.IObservable<T> FromTask<T>(System.Threading.Tasks.Task<T> task) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<TResult> FromTask<TResult>(System.Func<System.Threading.CancellationTokenSource, System.Threading.Tasks.Task<TResult>> actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<TResult> FromTask<TResult>(System.Func<System.Threading.CancellationTokenSource, System.Threading.Tasks.Task<TResult>> actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) { }
        public static ReactiveUI.Primitives.Signals.IAwaitSignal<TSource> GetAwaiter<TSource>(this System.IObservable<TSource> source) { }
        public static ReactiveUI.Primitives.Signals.IAwaitSignal<TSource> GetAwaiter<TSource>(this System.IObservable<TSource> source, System.Threading.CancellationToken cancellationToken) { }
        public static System.Threading.Tasks.Task HandleCancellation(this System.Threading.Tasks.Task asyncTask) { }
        public static System.Threading.Tasks.Task HandleCancellation(this System.Threading.Tasks.Task asyncTask, System.Action? action) { }
        public static System.Threading.Tasks.Task<TResult?> HandleCancellation<TResult>(this System.Threading.Tasks.Task<TResult> asyncTask) { }
        public static System.Threading.Tasks.Task<TResult?> HandleCancellation<TResult>(this System.IObservable<TResult> asyncTask, System.Threading.CancellationToken token) { }
        public static System.Threading.Tasks.Task<TResult?> HandleCancellation<TResult>(this System.Threading.Tasks.Task<TResult> asyncTask, System.Action? action) { }
        public static System.Threading.Tasks.Task<TResult?> HandleCancellation<TResult>(this System.IObservable<TResult> asyncTask, System.Action? action, System.Threading.CancellationToken token) { }
        public static System.IObservable<TResult> Iterate<TState, TResult>(TState initialState, System.Func<TState, bool> condition, System.Func<TState, TState> iterator, System.Func<TState, TResult> resultSelector) { }
        public static System.IObservable<T> Lazy<T>(System.Func<System.IObservable<T>> observableFactory) { }
        public static System.IObservable<T> Loop<T>(T value) { }
        public static System.IObservable<T> Loop<T>(T value, int count) { }
        public static System.IObservable<T> None<T>() { }
        public static System.IObservable<T> None<T>(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> None<T>(T witness) { }
        public static System.IObservable<T> None<T>(ReactiveUI.Primitives.Concurrency.ISequencer scheduler, T witness) { }
        public static System.IObservable<T> OnCleanup<T>(this System.IObservable<T> source, System.Action finallyAction) { }
        public static System.IObservable<TResult> Pair<TLeft, TRight, TResult>(System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<TResult> PairLatest<TLeft, TRight, TResult>(System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<long> Pulse(System.TimeSpan period) { }
        public static System.IObservable<long> Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> Race<T>(params System.IObservable<T>[] sources) { }
        public static System.IObservable<TSource> Recover<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
        public static System.IObservable<TSource> Recover<TSource>(params System.IObservable<TSource>[] sources) { }
        public static System.IObservable<TSource> Recover<TSource, TException>(this System.IObservable<TSource> source, System.Func<TException, System.IObservable<TSource>> handler)
            where TException : System.Exception { }
        public static System.IObservable<int> Sequence(int start, int count) { }
        public static System.IObservable<int> Sequence(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> Silent<T>() { }
        public static System.IObservable<T> Silent<T>(T witness) { }
        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Start(System.Action action) { }
        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Start(System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<T> Start<T>(System.Func<T> function) { }
        public static System.IObservable<T> Start<T>(System.Func<T> function, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
        public static System.IObservable<TResult> SyncLatest<TLeft, TRight, TResult>(System.IObservable<TLeft> left, System.IObservable<TRight> right, System.Func<TLeft, TRight, TResult> selector) { }
        public static System.IObservable<TResult> Unfold<TState, TResult>(TState initialState, System.Func<TState, bool> condition, System.Func<TState, TState> iterate, System.Func<TState, TResult> resultSelector) { }
        public static System.IObservable<T> Use<TResource, T>(System.Func<TResource> resourceFactory, System.Func<TResource, System.IObservable<T>> signalFactory)
            where TResource : System.IDisposable { }
        public static System.IObservable<T> WitnessOn<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class Signal<T> : ReactiveUI.Primitives.Disposables.IsDisposed, ReactiveUI.Primitives.Signals.ISignal<T>, ReactiveUI.Primitives.Signals.ISignal<T, T>, System.IDisposable, System.IObservable<T>, System.IObserver<T>
    {
        public Signal() { }
        public virtual bool HasObservers { get; }
        public virtual bool IsDisposed { get; }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public void OnCompleted() { }
        public void OnError(System.Exception error) { }
        public void OnNext(T value) { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    public static class StateSignalMixins
    {
        public static ReactiveUI.Primitives.Signals.ReadOnlyState<TResult> ToReadOnlyState<TSource, TResult>(this System.IObservable<TSource> source, TResult initialValue, System.Func<TSource, TResult> selector) { }
    }
    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class StateSignal<T> : ReactiveUI.Primitives.Signals.BehaviorSignal<T>
    {
        public StateSignal(T initialValue) { }
        public System.IObservable<T> Changed { get; }
        public new T Value { get; set; }
        public void Refresh() { }
        public ReactiveUI.Primitives.Signals.ProjectedReadOnlyState<T, TResult> ToReadOnlyState<TResult>(System.Func<T, TResult> selector) { }
    }
    public static class TaskSignal
    {
        public static ReactiveUI.Primitives.Signals.ITaskSignal<TResult> Create<TResult>(System.Func<ReactiveUI.Primitives.Signals.ITaskSignal<TResult>, System.IObservable<TResult>> observableFactory) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<TResult> Create<TResult>(System.Func<ReactiveUI.Primitives.Signals.ITaskSignal<TResult>, System.IObservable<TResult>> observableFactory, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
        public static ReactiveUI.Primitives.Signals.ITaskSignal<TResult> Create<TResult>(System.Func<ReactiveUI.Primitives.Signals.ITaskSignal<TResult>, System.IObservable<TResult>> observableFactory, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) { }
    }
}