ApiApprovalTests.ReactiveUI.approved.txt

[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("ReactiveUI.AndroidSupport")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("ReactiveUI.Tests")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("ReactiveUI.Winforms")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("ReactiveUI.Wpf")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("ReactiveUI.XamForms")]
[assembly: System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.6.1", FrameworkDisplayName=".NET Framework 4.6.1")]
namespace ReactiveUI
{
    public class static AutoPersistHelper
    {
        public static System.IDisposable ActOnEveryObject<TItem>(this System.Collections.ObjectModel.ObservableCollection<TItem> @this, System.Action<TItem> onAdd, System.Action<TItem> onRemove)
            where TItem : ReactiveUI.IReactiveObject { }
        public static System.IDisposable ActOnEveryObject<TItem>(this System.Collections.ObjectModel.ReadOnlyObservableCollection<TItem> @this, System.Action<TItem> onAdd, System.Action<TItem> onRemove)
            where TItem : ReactiveUI.IReactiveObject { }
        public static System.IDisposable ActOnEveryObject<TItem, TCollection>(this TCollection @this, System.Action<TItem> onAdd, System.Action<TItem> onRemove)
            where TItem : ReactiveUI.IReactiveObject
            where TCollection : System.Collections.Specialized.INotifyCollectionChanged, System.Collections.Generic.IEnumerable<> { }
        public static System.IDisposable ActOnEveryObject<TItem>(this System.IObservable<DynamicData.IChangeSet<TItem>> @this, System.Action<TItem> onAdd, System.Action<TItem> onRemove)
            where TItem : ReactiveUI.IReactiveObject { }
        public static System.IDisposable AutoPersist<T>(this T @this, System.Func<T, System.IObservable<System.Reactive.Unit>> doPersist, System.Nullable<System.TimeSpan> interval = null)
            where T : ReactiveUI.IReactiveObject { }
        public static System.IDisposable AutoPersist<T, TDontCare>(this T @this, System.Func<T, System.IObservable<System.Reactive.Unit>> doPersist, System.IObservable<TDontCare> manualSaveSignal, System.Nullable<System.TimeSpan> interval = null)
            where T : ReactiveUI.IReactiveObject { }
        public static System.IDisposable AutoPersistCollection<TItem>(this System.Collections.ObjectModel.ObservableCollection<TItem> @this, System.Func<TItem, System.IObservable<System.Reactive.Unit>> doPersist, System.Nullable<System.TimeSpan> interval = null)
            where TItem : ReactiveUI.IReactiveObject { }
        public static System.IDisposable AutoPersistCollection<TItem, TDontCare>(this System.Collections.ObjectModel.ObservableCollection<TItem> @this, System.Func<TItem, System.IObservable<System.Reactive.Unit>> doPersist, System.IObservable<TDontCare> manualSaveSignal, System.Nullable<System.TimeSpan> interval = null)
            where TItem : ReactiveUI.IReactiveObject { }
        public static System.IDisposable AutoPersistCollection<TItem, TDontCare>(this System.Collections.ObjectModel.ReadOnlyObservableCollection<TItem> @this, System.Func<TItem, System.IObservable<System.Reactive.Unit>> doPersist, System.IObservable<TDontCare> manualSaveSignal, System.Nullable<System.TimeSpan> interval = null)
            where TItem : ReactiveUI.IReactiveObject { }
        public static System.IDisposable AutoPersistCollection<TItem, TCollection, TDontCare>(this TCollection @this, System.Func<TItem, System.IObservable<System.Reactive.Unit>> doPersist, System.IObservable<TDontCare> manualSaveSignal, System.Nullable<System.TimeSpan> interval = null)
            where TItem : ReactiveUI.IReactiveObject
            where TCollection : System.Collections.Specialized.INotifyCollectionChanged, System.Collections.Generic.IEnumerable<> { }
    }
    public enum BindingDirection
    {
        OneWay = 0,
        TwoWay = 1,
        AsyncOneWay = 2,
    }
    public class CanActivateViewFetcher : ReactiveUI.IActivationForViewFetcher
    {
        public CanActivateViewFetcher() { }
        public System.IObservable<bool> GetActivationForView(ReactiveUI.IActivatable view) { }
        public int GetAffinityForView(System.Type view) { }
    }
    public class static ChangeSetMixin
    {
        public static System.IObservable<DynamicData.IChangeSet> CountChanged(this System.IObservable<DynamicData.IChangeSet> changeSet) { }
        public static System.IObservable<DynamicData.IChangeSet<T>> CountChanged<T>(this System.IObservable<DynamicData.IChangeSet<T>> changeSet) { }
        public static bool HasCountChanged(this DynamicData.IChangeSet changeSet) { }
    }
    public class CombinedReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, System.Collections.Generic.IList<TResult>>
    {
        protected internal CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler) { }
        public override System.IObservable<bool> CanExecute { get; }
        public override System.IObservable<bool> IsExecuting { get; }
        public override System.IObservable<System.Exception> ThrownExceptions { get; }
        protected override void Dispose(bool disposing) { }
        public override System.IObservable<System.Collections.Generic.IList<TResult>> Execute(TParam parameter = null) { }
        public override System.IDisposable Subscribe(System.IObserver<System.Collections.Generic.IList<TResult>> observer) { }
    }
    public class static CommandBinder
    {
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, TProp> BindCommand<TView, TViewModel, TProp, TControl, TParam>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> propertyName, System.Linq.Expressions.Expression<System.Func<TView, TControl>> controlName, System.IObservable<TParam> withParameter, string toEvent = null)
            where TView :  class, ReactiveUI.IViewFor<>
            where TViewModel :  class
            where TProp : System.Windows.Input.ICommand { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, TProp> BindCommand<TView, TViewModel, TProp, TControl>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> propertyName, System.Linq.Expressions.Expression<System.Func<TView, TControl>> controlName, string toEvent = null)
            where TView :  class, ReactiveUI.IViewFor<>
            where TViewModel :  class
            where TProp : System.Windows.Input.ICommand { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, TProp> BindCommand<TView, TViewModel, TProp, TControl, TParam>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> propertyName, System.Linq.Expressions.Expression<System.Func<TView, TControl>> controlName, System.Linq.Expressions.Expression<System.Func<TViewModel, TParam>> withParameter, string toEvent = null)
            where TView :  class, ReactiveUI.IViewFor<>
            where TViewModel :  class
            where TProp : System.Windows.Input.ICommand { }
    }
    public class CommandBinderImplementation : Splat.IEnableLogger
    {
        public CommandBinderImplementation() { }
        public ReactiveUI.IReactiveBinding<TView, TViewModel, TProp> BindCommand<TView, TViewModel, TProp, TControl, TParam>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TControl>> controlProperty, System.Func<TParam> withParameter, string toEvent = null)
            where TView :  class, ReactiveUI.IViewFor<>
            where TViewModel :  class
            where TProp : System.Windows.Input.ICommand { }
        public ReactiveUI.IReactiveBinding<TView, TViewModel, TProp> BindCommand<TView, TViewModel, TProp, TControl, TParam>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TControl>> controlProperty, System.IObservable<TParam> withParameter, string toEvent = null)
            where TView :  class, ReactiveUI.IViewFor<>
            where TViewModel :  class
            where TProp : System.Windows.Input.ICommand { }
    }
    public class static ComparerChainingExtensions
    {
        public static System.Collections.Generic.IComparer<T> ThenBy<T, TValue>(this System.Collections.Generic.IComparer<T> parent, System.Func<T, TValue> selector) { }
        public static System.Collections.Generic.IComparer<T> ThenBy<T, TValue>(this System.Collections.Generic.IComparer<T> parent, System.Func<T, TValue> selector, System.Collections.Generic.IComparer<TValue> comparer) { }
        public static System.Collections.Generic.IComparer<T> ThenByDescending<T, TValue>(this System.Collections.Generic.IComparer<T> parent, System.Func<T, TValue> selector) { }
        public static System.Collections.Generic.IComparer<T> ThenByDescending<T, TValue>(this System.Collections.Generic.IComparer<T> parent, System.Func<T, TValue> selector, System.Collections.Generic.IComparer<TValue> comparer) { }
    }
    public class ComponentModelTypeConverter : ReactiveUI.IBindingTypeConverter, Splat.IEnableLogger
    {
        public ComponentModelTypeConverter() { }
        public int GetAffinityForObjects(System.Type fromType, System.Type toType) { }
        public bool TryConvert(object from, System.Type toType, object conversionHint, out object result) { }
    }
    public class CreatesCommandBindingViaCommandParameter : ReactiveUI.ICreatesCommandBinding
    {
        public CreatesCommandBindingViaCommandParameter() { }
        public System.IDisposable BindCommandToObject(System.Windows.Input.ICommand command, object target, System.IObservable<object> commandParameter) { }
        public System.IDisposable BindCommandToObject<TEventArgs>(System.Windows.Input.ICommand command, object target, System.IObservable<object> commandParameter, string eventName) { }
        public int GetAffinityForObject(System.Type type, bool hasEventTarget) { }
    }
    public class CreatesCommandBindingViaEvent : ReactiveUI.ICreatesCommandBinding
    {
        public CreatesCommandBindingViaEvent() { }
        public System.IDisposable BindCommandToObject(System.Windows.Input.ICommand command, object target, System.IObservable<object> commandParameter) { }
        public System.IDisposable BindCommandToObject<TEventArgs>(System.Windows.Input.ICommand command, object target, System.IObservable<object> commandParameter, string eventName) { }
        public int GetAffinityForObject(System.Type type, bool hasEventTarget) { }
    }
    public class static DependencyResolverMixins
    {
        public static void InitializeReactiveUI(this Splat.IMutableDependencyResolver resolver) { }
        public static void RegisterViewsForViewModels(this Splat.IMutableDependencyResolver resolver, System.Reflection.Assembly assembly) { }
    }
    public class DummySuspensionDriver : ReactiveUI.ISuspensionDriver
    {
        public DummySuspensionDriver() { }
        public System.IObservable<System.Reactive.Unit> InvalidateState() { }
        public System.IObservable<object> LoadState() { }
        public System.IObservable<System.Reactive.Unit> SaveState(object state) { }
    }
    public class EqualityTypeConverter : ReactiveUI.IBindingTypeConverter, Splat.IEnableLogger
    {
        public EqualityTypeConverter() { }
        public static object DoReferenceCast(object from, System.Type targetType) { }
        public int GetAffinityForObjects(System.Type fromType, System.Type toType) { }
        public bool TryConvert(object from, System.Type toType, object conversionHint, out object result) { }
    }
    public class static ExpressionMixins
    {
        public static object[] GetArgumentsArray(this System.Linq.Expressions.Expression expression) { }
        public static System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> GetExpressionChain(this System.Linq.Expressions.Expression @this) { }
        public static System.Reflection.MemberInfo GetMemberInfo(this System.Linq.Expressions.Expression expression) { }
        public static System.Linq.Expressions.Expression GetParent(this System.Linq.Expressions.Expression expression) { }
    }
    public interface IActivatable { }
    public interface IActivationForViewFetcher
    {
        System.IObservable<bool> GetActivationForView(ReactiveUI.IActivatable view);
        int GetAffinityForView(System.Type view);
    }
    public interface IBindingTypeConverter : Splat.IEnableLogger
    {
        int GetAffinityForObjects(System.Type fromType, System.Type toType);
        bool TryConvert(object from, System.Type toType, object conversionHint, out object result);
    }
    public interface ICanActivate
    {
        System.IObservable<System.Reactive.Unit> Activated { get; }
        System.IObservable<System.Reactive.Unit> Deactivated { get; }
    }
    public interface IComparerBuilder<T>
    {
        System.Collections.Generic.IComparer<T> OrderBy<TValue>(System.Func<T, TValue> selector);
        System.Collections.Generic.IComparer<T> OrderBy<TValue>(System.Func<T, TValue> selector, System.Collections.Generic.IComparer<TValue> comparer);
        System.Collections.Generic.IComparer<T> OrderByDescending<TValue>(System.Func<T, TValue> selector);
        System.Collections.Generic.IComparer<T> OrderByDescending<TValue>(System.Func<T, TValue> selector, System.Collections.Generic.IComparer<TValue> comparer);
    }
    public interface ICreatesCommandBinding
    {
        System.IDisposable BindCommandToObject(System.Windows.Input.ICommand command, object target, System.IObservable<object> commandParameter);
        System.IDisposable BindCommandToObject<TEventArgs>(System.Windows.Input.ICommand command, object target, System.IObservable<object> commandParameter, string eventName);
        int GetAffinityForObject(System.Type type, bool hasEventTarget);
    }
    public interface ICreatesObservableForProperty : Splat.IEnableLogger
    {
        int GetAffinityForObject(System.Type type, string propertyName, bool beforeChanged = False);
        System.IObservable<ReactiveUI.IObservedChange<object, object>> GetNotificationForProperty(object sender, System.Linq.Expressions.Expression expression, string propertyName, bool beforeChanged = False, bool suppressWarnings = False);
    }
    public interface IHandleObservableErrors
    {
        System.IObservable<System.Exception> ThrownExceptions { get; }
    }
    public interface IMessageBus : Splat.IEnableLogger
    {
        bool IsRegistered(System.Type type, string contract = null);
        System.IObservable<T> Listen<T>(string contract = null);
        System.IObservable<T> ListenIncludeLatest<T>(string contract = null);
        System.IDisposable RegisterMessageSource<T>(System.IObservable<T> source, string contract = null);
        void RegisterScheduler<T>(System.Reactive.Concurrency.IScheduler scheduler, string contract = null);
        void SendMessage<T>(T message, string contract = null);
    }
    public interface INotifyCollectionChanging
    {
        public event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanging;
    }
    public interface INotifyPropertyChanging
    {
        public event ReactiveUI.PropertyChangingEventHandler PropertyChanging;
    }
    public class INPCObservableForProperty : ReactiveUI.ICreatesObservableForProperty, Splat.IEnableLogger
    {
        public INPCObservableForProperty() { }
        public int GetAffinityForObject(System.Type type, string propertyName, bool beforeChanged) { }
        public System.IObservable<ReactiveUI.IObservedChange<object, object>> GetNotificationForProperty(object sender, System.Linq.Expressions.Expression expression, string propertyName, bool beforeChanged, bool suppressWarnings = False) { }
    }
    public class Interaction<TInput, TOutput>
    {
        public Interaction(System.Reactive.Concurrency.IScheduler handlerScheduler = null) { }
        protected System.Func<, >[] GetHandlers() { }
        public virtual System.IObservable<TOutput> Handle(TInput input) { }
        public System.IDisposable RegisterHandler(System.Action<ReactiveUI.InteractionContext<TInput, TOutput>> handler) { }
        public System.IDisposable RegisterHandler(System.Func<ReactiveUI.InteractionContext<TInput, TOutput>, System.Threading.Tasks.Task> handler) { }
        public System.IDisposable RegisterHandler<TDontCare>(System.Func<ReactiveUI.InteractionContext<TInput, TOutput>, System.IObservable<TDontCare>> handler) { }
    }
    public sealed class InteractionContext<TInput, TOutput>
    {
        public TInput Input { get; }
        public bool IsHandled { get; }
        public TOutput GetOutput() { }
        public void SetOutput(TOutput output) { }
    }
    public interface IObservedChange<out TSender, out TValue>
    {
        System.Linq.Expressions.Expression Expression { get; }
        TSender Sender { get; }
        TValue Value { get; }
    }
    public interface IPropertyBinderImplementation : Splat.IEnableLogger
    {
        ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp, TDontCare>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.IObservable<TDontCare> signalViewUpdate, object conversionHint, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null, ReactiveUI.IBindingTypeConverter viewToVMConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor
        ;
        ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp, TDontCare>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.IObservable<TDontCare> signalViewUpdate, System.Func<TVMProp, TVProp> vmToViewConverter, System.Func<TVProp, TVMProp> viewToVmConverter)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor
        ;
        System.IDisposable BindTo<TValue, TTarget, TTValue>(System.IObservable<TValue> observedChange, TTarget target, System.Linq.Expressions.Expression<System.Func<TTarget, TTValue>> propertyExpression, object conversionHint, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null)
            where TTarget :  class
        ;
        ReactiveUI.IReactiveBinding<TView, TViewModel, TVProp> OneWayBind<TViewModel, TView, TVMProp, TVProp>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, object conversionHint, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor
        ;
        ReactiveUI.IReactiveBinding<TView, TViewModel, TOut> OneWayBind<TViewModel, TView, TProp, TOut>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TOut>> viewProperty, System.Func<TProp, TOut> selector)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor
        ;
    }
    public interface IPropertyBindingHook
    {
        bool ExecuteHook(object source, object target, System.Func<ReactiveUI.IObservedChange<, >[]> getCurrentViewModelProperties, System.Func<ReactiveUI.IObservedChange<, >[]> getCurrentViewProperties, ReactiveUI.BindingDirection direction);
    }
    public interface IReactiveBinding<out TView, out TViewModel, out TValue> : System.IDisposable
        where out TView : ReactiveUI.IViewFor
        where out TViewModel :  class
    {
        System.IObservable<TValue> Changed { get; }
        ReactiveUI.BindingDirection Direction { get; }
        TView View { get; }
        System.Linq.Expressions.Expression ViewExpression { get; }
        TViewModel ViewModel { get; }
        System.Linq.Expressions.Expression ViewModelExpression { get; }
    }
    public interface IReactiveCommand : ReactiveUI.IHandleObservableErrors, System.IDisposable
    {
        System.IObservable<bool> CanExecute { get; }
        System.IObservable<bool> IsExecuting { get; }
    }
    public interface IReactiveNotifyPropertyChanged<out TSender>
    {
        System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<TSender>> Changed { get; }
        System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<TSender>> Changing { get; }
        System.IDisposable SuppressChangeNotifications();
    }
    public interface IReactiveObject : ReactiveUI.INotifyPropertyChanging, Splat.IEnableLogger, System.ComponentModel.INotifyPropertyChanged
    {
        void RaisePropertyChanged(System.ComponentModel.PropertyChangedEventArgs args);
        void RaisePropertyChanging(ReactiveUI.PropertyChangingEventArgs args);
    }
    public class static IReactiveObjectExtensions
    {
        public static TRet RaiseAndSetIfChanged<TObj, TRet>(this TObj @this, ref TRet backingField, TRet newValue, [System.Runtime.CompilerServices.CallerMemberNameAttribute()] string propertyName = null)
            where TObj : ReactiveUI.IReactiveObject { }
        public static void RaisePropertyChanged<TSender>(this TSender @this, [System.Runtime.CompilerServices.CallerMemberNameAttribute()] string propertyName = null)
            where TSender : ReactiveUI.IReactiveObject { }
        public static void RaisePropertyChanging<TSender>(this TSender @this, [System.Runtime.CompilerServices.CallerMemberNameAttribute()] string propertyName = null)
            where TSender : ReactiveUI.IReactiveObject { }
    }
    public interface IReactivePropertyChangedEventArgs<out TSender>
    {
        string PropertyName { get; }
        TSender Sender { get; }
    }
    public class IROObservableForProperty : ReactiveUI.ICreatesObservableForProperty, Splat.IEnableLogger
    {
        public IROObservableForProperty() { }
        public int GetAffinityForObject(System.Type type, string propertyName, bool beforeChanged = False) { }
        public System.IObservable<ReactiveUI.IObservedChange<object, object>> GetNotificationForProperty(object sender, System.Linq.Expressions.Expression expression, string propertyName, bool beforeChanged = False, bool suppressWarnings = False) { }
    }
    public interface IRoutableViewModel : ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, Splat.IEnableLogger, System.ComponentModel.INotifyPropertyChanged
    {
        ReactiveUI.IScreen HostScreen { get; }
        string UrlPathSegment { get; }
    }
    public interface IScreen
    {
        ReactiveUI.RoutingState Router { get; }
    }
    public interface ISupportsActivation
    {
        ReactiveUI.ViewModelActivator Activator { get; }
    }
    public interface ISuspensionDriver
    {
        System.IObservable<System.Reactive.Unit> InvalidateState();
        System.IObservable<object> LoadState();
        System.IObservable<System.Reactive.Unit> SaveState(object state);
    }
    public interface ISuspensionHost : ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, Splat.IEnableLogger, System.ComponentModel.INotifyPropertyChanged
    {
        object AppState { get; set; }
        System.Func<object> CreateNewAppState { get; set; }
        System.IObservable<System.Reactive.Unit> IsLaunchingNew { get; set; }
        System.IObservable<System.Reactive.Unit> IsResuming { get; set; }
        System.IObservable<System.Reactive.Unit> IsUnpausing { get; set; }
        System.IObservable<System.Reactive.Unit> ShouldInvalidateState { get; set; }
        System.IObservable<System.IDisposable> ShouldPersistState { get; set; }
    }
    public interface IViewFor : ReactiveUI.IActivatable
    {
        object ViewModel { get; set; }
    }
    public interface IViewFor<T> : ReactiveUI.IActivatable, ReactiveUI.IViewFor
        where T :  class
    {
        T ViewModel { get; set; }
    }
    public interface IViewLocator : Splat.IEnableLogger
    {
        ReactiveUI.IViewFor ResolveView<T>(T viewModel, string contract = null)
            where T :  class;
    }
    public class MessageBus : ReactiveUI.IMessageBus, Splat.IEnableLogger
    {
        public MessageBus() { }
        public static ReactiveUI.IMessageBus Current { get; set; }
        public bool IsRegistered(System.Type type, string contract = null) { }
        public System.IObservable<T> Listen<T>(string contract = null) { }
        public System.IObservable<T> ListenIncludeLatest<T>(string contract = null) { }
        public System.IDisposable RegisterMessageSource<T>(System.IObservable<T> source, string contract = null) { }
        public void RegisterScheduler<T>(System.Reactive.Concurrency.IScheduler scheduler, string contract = null) { }
        public void SendMessage<T>(T message, string contract = null) { }
    }
    public class static OAPHCreationHelperMixin
    {
        public static ReactiveUI.ObservableAsPropertyHelper<TRet> ToProperty<TObj, TRet>(this System.IObservable<TRet> target, TObj source, System.Linq.Expressions.Expression<System.Func<TObj, TRet>> property, TRet initialValue = null, bool deferSubscription = False, System.Reactive.Concurrency.IScheduler scheduler = null)
            where TObj :  class, ReactiveUI.IReactiveObject { }
        public static ReactiveUI.ObservableAsPropertyHelper<TRet> ToProperty<TObj, TRet>(this System.IObservable<TRet> target, TObj source, System.Linq.Expressions.Expression<System.Func<TObj, TRet>> property, out ReactiveUI.ObservableAsPropertyHelper<> result, TRet initialValue = null, bool deferSubscription = False, System.Reactive.Concurrency.IScheduler scheduler = null)
            where TObj :  class, ReactiveUI.IReactiveObject { }
        public static ReactiveUI.ObservableAsPropertyHelper<TRet> ToProperty<TObj, TRet>(this System.IObservable<TRet> target, TObj source, string property, TRet initialValue = null, bool deferSubscription = False, System.Reactive.Concurrency.IScheduler scheduler = null)
            where TObj :  class, ReactiveUI.IReactiveObject { }
        public static ReactiveUI.ObservableAsPropertyHelper<TRet> ToProperty<TObj, TRet>(this System.IObservable<TRet> target, TObj source, string property, out ReactiveUI.ObservableAsPropertyHelper<> result, TRet initialValue = null, bool deferSubscription = False, System.Reactive.Concurrency.IScheduler scheduler = null)
            where TObj :  class, ReactiveUI.IReactiveObject { }
    }
    public sealed class ObservableAsPropertyHelper<T> : ReactiveUI.IHandleObservableErrors, Splat.IEnableLogger, System.IDisposable
    {
        public ObservableAsPropertyHelper(System.IObservable<T> observable, System.Action<T> onChanged, T initialValue = null, bool deferSubscription = False, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public ObservableAsPropertyHelper(System.IObservable<T> observable, System.Action<T> onChanged, System.Action<T> onChanging = null, T initialValue = null, bool deferSubscription = False, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public bool IsSubscribed { get; }
        public System.IObservable<System.Exception> ThrownExceptions { get; }
        public T Value { get; }
        public static ReactiveUI.ObservableAsPropertyHelper<T> Default(T initialValue = null, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public void Dispose() { }
    }
    public class static ObservableLoggingMixin
    {
        public static System.IObservable<T> Log<T, TObj>(this System.IObservable<T> @this, TObj klass, string message = null, System.Func<T, string> stringifier = null)
            where TObj : Splat.IEnableLogger { }
        public static System.IObservable<T> LoggedCatch<T, TObj>(this System.IObservable<T> @this, TObj klass, System.IObservable<T> next = null, string message = null)
            where TObj : Splat.IEnableLogger { }
        public static System.IObservable<T> LoggedCatch<T, TObj, TException>(this System.IObservable<T> @this, TObj klass, System.Func<TException, System.IObservable<T>> next, string message = null)
            where TObj : Splat.IEnableLogger
            where TException : System.Exception { }
    }
    public class ObservedChange<TSender, TValue> : ReactiveUI.IObservedChange<TSender, TValue>
    {
        public ObservedChange(TSender sender, System.Linq.Expressions.Expression expression, TValue value = null) { }
        public System.Linq.Expressions.Expression Expression { get; }
        public TSender Sender { get; }
        public TValue Value { get; }
    }
    public class static ObservedChangedMixin
    {
        public static string GetPropertyName<TSender, TValue>(this ReactiveUI.IObservedChange<TSender, TValue> @this) { }
        public static TValue GetValue<TSender, TValue>(this ReactiveUI.IObservedChange<TSender, TValue> @this) { }
        public static System.IObservable<TValue> Value<TSender, TValue>(this System.IObservable<ReactiveUI.IObservedChange<TSender, TValue>> @this) { }
    }
    public class static OrderedComparer
    {
        public static ReactiveUI.IComparerBuilder<T> For<T>(System.Collections.Generic.IEnumerable<T> enumerable) { }
        public static ReactiveUI.IComparerBuilder<T> For<T>() { }
    }
    public class static OrderedComparer<T>
    {
        public static System.Collections.Generic.IComparer<T> OrderBy<TValue>(System.Func<T, TValue> selector) { }
        public static System.Collections.Generic.IComparer<T> OrderBy<TValue>(System.Func<T, TValue> selector, System.Collections.Generic.IComparer<TValue> comparer) { }
        public static System.Collections.Generic.IComparer<T> OrderByDescending<TValue>(System.Func<T, TValue> selector) { }
        public static System.Collections.Generic.IComparer<T> OrderByDescending<TValue>(System.Func<T, TValue> selector, System.Collections.Generic.IComparer<TValue> comparer) { }
    }
    public class PlatformRegistrations
    {
        public PlatformRegistrations() { }
        public void Register(System.Action<System.Func<object>, System.Type> registerFunction) { }
    }
    public class POCOObservableForProperty : ReactiveUI.ICreatesObservableForProperty, Splat.IEnableLogger
    {
        public POCOObservableForProperty() { }
        public int GetAffinityForObject(System.Type type, string propertyName, bool beforeChanged = False) { }
        public System.IObservable<ReactiveUI.IObservedChange<object, object>> GetNotificationForProperty(object sender, System.Linq.Expressions.Expression expression, string propertyName, bool beforeChanged = False, bool suppressWarnings = False) { }
    }
    public class PropertyBinderImplementation : ReactiveUI.IPropertyBinderImplementation, Splat.IEnableLogger
    {
        public PropertyBinderImplementation() { }
        public ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp, TDontCare>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.IObservable<TDontCare> signalViewUpdate, object conversionHint, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null, ReactiveUI.IBindingTypeConverter viewToVMConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp, TDontCare>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.IObservable<TDontCare> signalViewUpdate, System.Func<TVMProp, TVProp> vmToViewConverter, System.Func<TVProp, TVMProp> viewToVmConverter)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public System.IDisposable BindTo<TValue, TTarget, TTValue>(System.IObservable<TValue> observedChange, TTarget target, System.Linq.Expressions.Expression<System.Func<TTarget, TTValue>> propertyExpression, object conversionHint = null, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null)
            where TTarget :  class { }
        public ReactiveUI.IReactiveBinding<TView, TViewModel, TVProp> OneWayBind<TViewModel, TView, TVMProp, TVProp>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, object conversionHint = null, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public ReactiveUI.IReactiveBinding<TView, TViewModel, TOut> OneWayBind<TViewModel, TView, TProp, TOut>(TViewModel viewModel, TView view, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TOut>> viewProperty, System.Func<TProp, TOut> selector)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
    }
    public class static PropertyBindingMixins
    {
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, object conversionHint = null, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null, ReactiveUI.IBindingTypeConverter viewToVMConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp, TDontCare>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.IObservable<TDontCare> signalViewUpdate, object conversionHint = null, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null, ReactiveUI.IBindingTypeConverter viewToVMConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.Func<TVMProp, TVProp> vmToViewConverter, System.Func<TVProp, TVMProp> viewToVmConverter)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, System.Tuple<object, bool>> Bind<TViewModel, TView, TVMProp, TVProp, TDontCare>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, System.IObservable<TDontCare> signalViewUpdate, System.Func<TVMProp, TVProp> vmToViewConverter, System.Func<TVProp, TVMProp> viewToVmConverter)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public static System.IDisposable BindTo<TValue, TTarget, TTValue>(this System.IObservable<TValue> @this, TTarget target, System.Linq.Expressions.Expression<System.Func<TTarget, TTValue>> property, object conversionHint = null, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null)
            where TTarget :  class { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, TVProp> OneWayBind<TViewModel, TView, TVMProp, TVProp>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TVMProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TVProp>> viewProperty, object conversionHint = null, ReactiveUI.IBindingTypeConverter vmToViewConverterOverride = null)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
        public static ReactiveUI.IReactiveBinding<TView, TViewModel, TOut> OneWayBind<TViewModel, TView, TProp, TOut>(this TView view, TViewModel viewModel, System.Linq.Expressions.Expression<System.Func<TViewModel, TProp>> vmProperty, System.Linq.Expressions.Expression<System.Func<TView, TOut>> viewProperty, System.Func<TProp, TOut> selector)
            where TViewModel :  class
            where TView :  class, ReactiveUI.IViewFor { }
    }
    public class PropertyChangingEventArgs : System.EventArgs
    {
        public PropertyChangingEventArgs(string propertyName) { }
        public string PropertyName { get; set; }
    }
    public delegate void PropertyChangingEventHandler(object sender, ReactiveUI.PropertyChangingEventArgs e);
    public class static ReactiveCommand
    {
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool> canExecute = null, System.Reactive.Concurrency.IScheduler outputScheduler = null) { }
    }
    public class ReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, TResult>
    {
        protected internal ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler) { }
        public override System.IObservable<bool> CanExecute { get; }
        public override System.IObservable<bool> IsExecuting { get; }
        public override System.IObservable<System.Exception> ThrownExceptions { get; }
        protected override void Dispose(bool disposing) { }
        public override System.IObservable<TResult> Execute(TParam parameter = null) { }
        public override System.IDisposable Subscribe(System.IObserver<TResult> observer) { }
    }
    public abstract class ReactiveCommandBase<TParam, TResult> : ReactiveUI.IHandleObservableErrors, ReactiveUI.IReactiveCommand, System.IDisposable, System.IObservable<TResult>, System.Windows.Input.ICommand
    {
        protected ReactiveCommandBase() { }
        public abstract System.IObservable<bool> CanExecute { get; }
        public abstract System.IObservable<bool> IsExecuting { get; }
        public abstract System.IObservable<System.Exception> ThrownExceptions { get; }
        public event System.EventHandler System.Windows.Input.ICommand.CanExecuteChanged;
        public void Dispose() { }
        protected abstract void Dispose(bool disposing);
        public abstract System.IObservable<TResult> Execute(TParam parameter = null);
        protected virtual bool ICommandCanExecute(object parameter) { }
        protected virtual void ICommandExecute(object parameter) { }
        protected void OnCanExecuteChanged() { }
        public abstract System.IDisposable Subscribe(System.IObserver<TResult> observer);
    }
    public class static ReactiveCommandMixins
    {
        public static System.IDisposable InvokeCommand<T>(this System.IObservable<T> @this, System.Windows.Input.ICommand command) { }
        public static System.IDisposable InvokeCommand<T, TResult>(this System.IObservable<T> @this, ReactiveUI.ReactiveCommandBase<T, TResult> command) { }
        public static System.IDisposable InvokeCommand<T, TTarget>(this System.IObservable<T> @this, TTarget target, System.Linq.Expressions.Expression<System.Func<TTarget, System.Windows.Input.ICommand>> commandProperty)
            where TTarget :  class { }
        public static System.IDisposable InvokeCommand<T, TResult, TTarget>(this System.IObservable<T> @this, TTarget target, System.Linq.Expressions.Expression<System.Func<TTarget, ReactiveUI.ReactiveCommandBase<T, TResult>>> commandProperty)
            where TTarget :  class { }
    }
    public class static ReactiveNotifyPropertyChangedMixin
    {
        public static System.IObservable<ReactiveUI.IObservedChange<TSender, TValue>> ObservableForProperty<TSender, TValue>(this TSender @this, System.Linq.Expressions.Expression<System.Func<TSender, TValue>> property, bool beforeChange = False, bool skipInitial = True)
            where TSender :  class { }
        public static System.IObservable<TRet> ObservableForProperty<TSender, TValue, TRet>(this TSender @this, System.Linq.Expressions.Expression<System.Func<TSender, TValue>> property, System.Func<TValue, TRet> selector, bool beforeChange = False)
            where TSender :  class { }
        public static System.IObservable<ReactiveUI.IObservedChange<TSender, TValue>> SubscribeToExpressionChain<TSender, TValue>(this TSender source, System.Linq.Expressions.Expression expression, bool beforeChange = False, bool skipInitial = True) { }
    }
    [System.Runtime.Serialization.DataContractAttribute()]
    public class ReactiveObject : ReactiveUI.IHandleObservableErrors, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveNotifyPropertyChanged<ReactiveUI.IReactiveObject>, ReactiveUI.IReactiveObject, Splat.IEnableLogger, System.ComponentModel.INotifyPropertyChanged
    {
        public ReactiveObject() { }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<ReactiveUI.IReactiveObject>> Changed { get; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<ReactiveUI.IReactiveObject>> Changing { get; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.IObservable<System.Exception> ThrownExceptions { get; }
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        public event ReactiveUI.PropertyChangingEventHandler PropertyChanging;
        public bool AreChangeNotificationsEnabled() { }
        public System.IDisposable DelayChangeNotifications() { }
        public System.IDisposable SuppressChangeNotifications() { }
    }
    public class ReactivePropertyChangedEventArgs<TSender> : System.ComponentModel.PropertyChangedEventArgs, ReactiveUI.IReactivePropertyChangedEventArgs<TSender>
    {
        public ReactivePropertyChangedEventArgs(TSender sender, string propertyName) { }
        public TSender Sender { get; }
    }
    public class ReactivePropertyChangingEventArgs<TSender> : ReactiveUI.PropertyChangingEventArgs, ReactiveUI.IReactivePropertyChangedEventArgs<TSender>
    {
        public ReactivePropertyChangingEventArgs(TSender sender, string propertyName) { }
        public TSender Sender { get; }
    }
    public class static Reflection
    {
        public static string ExpressionToPropertyNames(System.Linq.Expressions.Expression expression) { }
        public static System.Type GetEventArgsTypeForEvent(System.Type type, string eventName) { }
        public static System.Func<object, object[], object> GetValueFetcherForProperty(System.Reflection.MemberInfo member) { }
        public static System.Func<object, object[], object> GetValueFetcherOrThrow(System.Reflection.MemberInfo member) { }
        public static System.Action<object, object, object[]> GetValueSetterForProperty(System.Reflection.MemberInfo member) { }
        public static System.Action<object, object, object[]> GetValueSetterOrThrow(System.Reflection.MemberInfo member) { }
        public static bool IsStatic(this System.Reflection.PropertyInfo @this) { }
        public static System.Type ReallyFindType(string type, bool throwOnFailure) { }
        public static System.Linq.Expressions.Expression Rewrite(System.Linq.Expressions.Expression expression) { }
        public static void ThrowIfMethodsNotOverloaded(string callingTypeName, object targetObject, params string[] methodsToCheck) { }
        public static bool TryGetAllValuesForPropertyChain(out ReactiveUI.IObservedChange<, > changeValues, object current, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> expressionChain) { }
        public static bool TryGetValueForPropertyChain<TValue>(out TValue changeValue, object current, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> expressionChain) { }
        public static bool TrySetValueToPropertyChain<TValue>(object target, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> expressionChain, TValue value, bool shouldThrow = True) { }
    }
    public class Registrations
    {
        public Registrations() { }
        public void Register(System.Action<System.Func<object>, System.Type> registerFunction) { }
    }
    public class static RoutableViewModelMixin
    {
        public static System.IDisposable WhenNavigatedTo(this ReactiveUI.IRoutableViewModel @this, System.Func<System.IDisposable> onNavigatedTo) { }
        public static System.IObservable<System.Reactive.Unit> WhenNavigatedToObservable(this ReactiveUI.IRoutableViewModel @this) { }
        public static System.IObservable<System.Reactive.Unit> WhenNavigatingFromObservable(this ReactiveUI.IRoutableViewModel @this) { }
    }
    [System.Runtime.Serialization.DataContractAttribute()]
    public class RoutingState : ReactiveUI.ReactiveObject
    {
        public RoutingState() { }
        public RoutingState(System.Reactive.Concurrency.IScheduler scheduler) { }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.IObservable<ReactiveUI.IRoutableViewModel> CurrentViewModel { get; set; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public ReactiveUI.ReactiveCommand<ReactiveUI.IRoutableViewModel, ReactiveUI.IRoutableViewModel> Navigate { get; set; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public ReactiveUI.ReactiveCommand<ReactiveUI.IRoutableViewModel, ReactiveUI.IRoutableViewModel> NavigateAndReset { get; set; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> NavigateBack { get; set; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.IObservable<DynamicData.IChangeSet<ReactiveUI.IRoutableViewModel>> NavigationChanged { get; set; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.Collections.ObjectModel.ObservableCollection<ReactiveUI.IRoutableViewModel> NavigationStack { get; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public System.Reactive.Concurrency.IScheduler Scheduler { get; set; }
    }
    public class static RoutingStateMixins
    {
        public static T FindViewModelInStack<T>(this ReactiveUI.RoutingState @this)
            where T : ReactiveUI.IRoutableViewModel { }
        public static ReactiveUI.IRoutableViewModel GetCurrentViewModel(this ReactiveUI.RoutingState @this) { }
    }
    public class static RxApp
    {
        public const int BigCacheLimit = 256;
        public const int SmallCacheLimit = 64;
        public static System.IObserver<System.Exception> DefaultExceptionHandler { get; set; }
        public static System.Reactive.Concurrency.IScheduler MainThreadScheduler { get; set; }
        public static bool SupportsRangeNotifications { get; set; }
        public static bool SuppressViewCommandBindingMessage { get; set; }
        public static ReactiveUI.ISuspensionHost SuspensionHost { get; set; }
        public static System.Reactive.Concurrency.IScheduler TaskpoolScheduler { get; set; }
    }
    public class ScheduledSubject<T> : System.IDisposable, System.IObservable<T>, System.IObserver<T>, System.Reactive.Subjects.ISubject<T>, System.Reactive.Subjects.ISubject<T, T>
    {
        public ScheduledSubject(System.Reactive.Concurrency.IScheduler scheduler, System.IObserver<T> defaultObserver = null, System.Reactive.Subjects.ISubject<T> defaultSubject = null) { }
        public void Dispose() { }
        protected virtual void Dispose(bool isDisposing) { }
        public void OnCompleted() { }
        public void OnError(System.Exception error) { }
        public void OnNext(T value) { }
        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.All)]
    public class SingleInstanceViewAttribute : System.Attribute
    {
        public SingleInstanceViewAttribute() { }
    }
    public class StringConverter : ReactiveUI.IBindingTypeConverter, Splat.IEnableLogger
    {
        public StringConverter() { }
        public int GetAffinityForObjects(System.Type fromType, System.Type toType) { }
        public bool TryConvert(object from, System.Type toType, object conversionHint, out object result) { }
    }
    public class static SuspensionHostExtensions
    {
        public static T GetAppState<T>(this ReactiveUI.ISuspensionHost @this) { }
        public static System.IObservable<T> ObserveAppState<T>(this ReactiveUI.ISuspensionHost @this)
            where T :  class { }
        public static System.IDisposable SetupDefaultSuspendResume(this ReactiveUI.ISuspensionHost @this, ReactiveUI.ISuspensionDriver driver = null) { }
    }
    public class UnhandledErrorException : System.Exception
    {
        public UnhandledErrorException() { }
        public UnhandledErrorException(string message) { }
        public UnhandledErrorException(string message, System.Exception innerException) { }
        protected UnhandledErrorException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
    }
    public class UnhandledInteractionException<TInput, TOutput> : System.Exception
    {
        public UnhandledInteractionException(ReactiveUI.Interaction<TInput, TOutput> interaction, TInput input) { }
        public UnhandledInteractionException() { }
        public UnhandledInteractionException(string message) { }
        public UnhandledInteractionException(string message, System.Exception innerException) { }
        protected UnhandledInteractionException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
        public TInput Input { get; }
        public ReactiveUI.Interaction<TInput, TOutput> Interaction { get; }
        public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.All)]
    public class ViewContractAttribute : System.Attribute
    {
        public ViewContractAttribute(string contract) { }
        public string Contract { get; }
    }
    public class static ViewForMixins
    {
        public static void WhenActivated(this ReactiveUI.ISupportsActivation @this, System.Func<System.Collections.Generic.IEnumerable<System.IDisposable>> block) { }
        public static void WhenActivated(this ReactiveUI.ISupportsActivation @this, System.Action<System.Action<System.IDisposable>> block) { }
        public static void WhenActivated(this ReactiveUI.ISupportsActivation @this, System.Action<System.Reactive.Disposables.CompositeDisposable> block) { }
        public static System.IDisposable WhenActivated(this ReactiveUI.IActivatable @this, System.Func<System.Collections.Generic.IEnumerable<System.IDisposable>> block) { }
        public static System.IDisposable WhenActivated(this ReactiveUI.IActivatable @this, System.Func<System.Collections.Generic.IEnumerable<System.IDisposable>> block, ReactiveUI.IViewFor view) { }
        public static System.IDisposable WhenActivated(this ReactiveUI.IActivatable @this, System.Action<System.Action<System.IDisposable>> block) { }
        public static System.IDisposable WhenActivated(this ReactiveUI.IActivatable @this, System.Action<System.Action<System.IDisposable>> block, ReactiveUI.IViewFor view) { }
        public static System.IDisposable WhenActivated(this ReactiveUI.IActivatable @this, System.Action<System.Reactive.Disposables.CompositeDisposable> block, ReactiveUI.IViewFor view = null) { }
    }
    public class static ViewLocator
    {
        public static ReactiveUI.IViewLocator Current { get; }
    }
    public class ViewLocatorNotFoundException : System.Exception
    {
        public ViewLocatorNotFoundException() { }
        public ViewLocatorNotFoundException(string message) { }
        public ViewLocatorNotFoundException(string message, System.Exception innerException) { }
        protected ViewLocatorNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
    }
    public sealed class ViewModelActivator : System.IDisposable
    {
        public ViewModelActivator() { }
        public System.IObservable<System.Reactive.Unit> Activated { get; }
        public System.IObservable<System.Reactive.Unit> Deactivated { get; }
        public System.IDisposable Activate() { }
        public void Deactivate(bool ignoreRefCount = False) { }
        public void Dispose() { }
    }
    public class WaitForDispatcherScheduler : System.Reactive.Concurrency.IScheduler
    {
        public WaitForDispatcherScheduler(System.Func<System.Reactive.Concurrency.IScheduler> schedulerFactory) { }
        public System.DateTimeOffset Now { get; }
        public System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
        public System.IDisposable Schedule<TState>(TState state, System.TimeSpan dueTime, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
        public System.IDisposable Schedule<TState>(TState state, System.DateTimeOffset dueTime, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
    }
    public class WeakEventManager<TEventSource, TEventHandler, TEventArgs>
        where TEventSource :  class
        where TEventHandler :  class
    {
        protected WeakEventManager() { }
        public static void AddHandler(TEventSource source, TEventHandler handler) { }
        public static void DeliverEvent(TEventSource sender, TEventArgs args) { }
        public static void RemoveHandler(TEventSource source, TEventHandler handler) { }
        protected virtual void StartListening(object source) { }
        protected virtual void StopListening(object source) { }
    }
    public class static WhenAnyMixin
    {
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Func<ReactiveUI.IObservedChange<TSender, T1>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6, T7>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, ReactiveUI.IObservedChange<TSender, T7>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, ReactiveUI.IObservedChange<TSender, T7>, ReactiveUI.IObservedChange<TSender, T8>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, ReactiveUI.IObservedChange<TSender, T7>, ReactiveUI.IObservedChange<TSender, T8>, ReactiveUI.IObservedChange<TSender, T9>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Linq.Expressions.Expression<System.Func<TSender, T10>> property10, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, ReactiveUI.IObservedChange<TSender, T7>, ReactiveUI.IObservedChange<TSender, T8>, ReactiveUI.IObservedChange<TSender, T9>, ReactiveUI.IObservedChange<TSender, T10>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Linq.Expressions.Expression<System.Func<TSender, T10>> property10, System.Linq.Expressions.Expression<System.Func<TSender, T11>> property11, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, ReactiveUI.IObservedChange<TSender, T7>, ReactiveUI.IObservedChange<TSender, T8>, ReactiveUI.IObservedChange<TSender, T9>, ReactiveUI.IObservedChange<TSender, T10>, ReactiveUI.IObservedChange<TSender, T11>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAny<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Linq.Expressions.Expression<System.Func<TSender, T10>> property10, System.Linq.Expressions.Expression<System.Func<TSender, T11>> property11, System.Linq.Expressions.Expression<System.Func<TSender, T12>> property12, System.Func<ReactiveUI.IObservedChange<TSender, T1>, ReactiveUI.IObservedChange<TSender, T2>, ReactiveUI.IObservedChange<TSender, T3>, ReactiveUI.IObservedChange<TSender, T4>, ReactiveUI.IObservedChange<TSender, T5>, ReactiveUI.IObservedChange<TSender, T6>, ReactiveUI.IObservedChange<TSender, T7>, ReactiveUI.IObservedChange<TSender, T8>, ReactiveUI.IObservedChange<TSender, T9>, ReactiveUI.IObservedChange<TSender, T10>, ReactiveUI.IObservedChange<TSender, T11>, ReactiveUI.IObservedChange<TSender, T12>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Func<ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Linq.Expressions.Expression property7, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Linq.Expressions.Expression property7, System.Linq.Expressions.Expression property8, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Linq.Expressions.Expression property7, System.Linq.Expressions.Expression property8, System.Linq.Expressions.Expression property9, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Linq.Expressions.Expression property7, System.Linq.Expressions.Expression property8, System.Linq.Expressions.Expression property9, System.Linq.Expressions.Expression property10, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Linq.Expressions.Expression property7, System.Linq.Expressions.Expression property8, System.Linq.Expressions.Expression property9, System.Linq.Expressions.Expression property10, System.Linq.Expressions.Expression property11, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyDynamic<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression property1, System.Linq.Expressions.Expression property2, System.Linq.Expressions.Expression property3, System.Linq.Expressions.Expression property4, System.Linq.Expressions.Expression property5, System.Linq.Expressions.Expression property6, System.Linq.Expressions.Expression property7, System.Linq.Expressions.Expression property8, System.Linq.Expressions.Expression property9, System.Linq.Expressions.Expression property10, System.Linq.Expressions.Expression property11, System.Linq.Expressions.Expression property12, System.Func<ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, ReactiveUI.IObservedChange<TSender, object>, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, TRet>> property1)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Func<T1, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<System.Tuple<T1, T2>> WhenAnyValue<TSender, T1, T2>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Func<T1, T2, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<System.Tuple<T1, T2, T3>> WhenAnyValue<TSender, T1, T2, T3>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Func<T1, T2, T3, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<System.Tuple<T1, T2, T3, T4>> WhenAnyValue<TSender, T1, T2, T3, T4>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Func<T1, T2, T3, T4, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<System.Tuple<T1, T2, T3, T4, T5>> WhenAnyValue<TSender, T1, T2, T3, T4, T5>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Func<T1, T2, T3, T4, T5, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<System.Tuple<T1, T2, T3, T4, T5, T6>> WhenAnyValue<TSender, T1, T2, T3, T4, T5, T6>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Func<T1, T2, T3, T4, T5, T6, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<System.Tuple<T1, T2, T3, T4, T5, T6, T7>> WhenAnyValue<TSender, T1, T2, T3, T4, T5, T6, T7>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6, T7>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Func<T1, T2, T3, T4, T5, T6, T7, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Linq.Expressions.Expression<System.Func<TSender, T10>> property10, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Linq.Expressions.Expression<System.Func<TSender, T10>> property10, System.Linq.Expressions.Expression<System.Func<TSender, T11>> property11, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyValue<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, T1>> property1, System.Linq.Expressions.Expression<System.Func<TSender, T2>> property2, System.Linq.Expressions.Expression<System.Func<TSender, T3>> property3, System.Linq.Expressions.Expression<System.Func<TSender, T4>> property4, System.Linq.Expressions.Expression<System.Func<TSender, T5>> property5, System.Linq.Expressions.Expression<System.Func<TSender, T6>> property6, System.Linq.Expressions.Expression<System.Func<TSender, T7>> property7, System.Linq.Expressions.Expression<System.Func<TSender, T8>> property8, System.Linq.Expressions.Expression<System.Func<TSender, T9>> property9, System.Linq.Expressions.Expression<System.Func<TSender, T10>> property10, System.Linq.Expressions.Expression<System.Func<TSender, T11>> property11, System.Linq.Expressions.Expression<System.Func<TSender, T12>> property12, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TRet> selector)
            where TSender :  class { }
    }
    public class static WhenAnyObservableMixin
    {
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs7)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs8)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs9)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs9, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs10)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs9, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs10, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs11)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs9, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs10, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs11, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<TRet>>> obs12)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Func<T1, T2, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Func<T1, T2, T3, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Func<T1, T2, T3, T4, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Func<T1, T2, T3, T4, T5, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Func<T1, T2, T3, T4, T5, T6, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6, T7>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T7>>> obs7, System.Func<T1, T2, T3, T4, T5, T6, T7, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T7>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T8>>> obs8, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T7>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T8>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T9>>> obs9, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T7>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T8>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T9>>> obs9, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T10>>> obs10, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T7>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T8>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T9>>> obs9, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T10>>> obs10, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T11>>> obs11, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TRet> selector)
            where TSender :  class { }
        public static System.IObservable<TRet> WhenAnyObservable<TSender, TRet, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this TSender This, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T1>>> obs1, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T2>>> obs2, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T3>>> obs3, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T4>>> obs4, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T5>>> obs5, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T6>>> obs6, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T7>>> obs7, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T8>>> obs8, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T9>>> obs9, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T10>>> obs10, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T11>>> obs11, System.Linq.Expressions.Expression<System.Func<TSender, System.IObservable<T12>>> obs12, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TRet> selector)
            where TSender :  class { }
    }
}
namespace ReactiveUI.Legacy
{
    public interface IMoveInfo<out T>
    {
        int From { get; }
        System.Collections.Generic.IEnumerable<T> MovedItems { get; }
        int To { get; }
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReactiveCollection<out T> : ReactiveUI.INotifyCollectionChanging, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, ReactiveUI.Legacy.IReactiveNotifyCollectionChanged<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionItemChanged<T>, Splat.IEnableLogger, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged
    {
        void Reset();
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReactiveDerivedList<out T> : ReactiveUI.INotifyCollectionChanging, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, ReactiveUI.Legacy.IReactiveCollection<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionChanged<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionItemChanged<T>, ReactiveUI.Legacy.IReadOnlyReactiveCollection<T>, ReactiveUI.Legacy.IReadOnlyReactiveList<T>, Splat.IEnableLogger, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged, System.IDisposable { }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReactiveList<T> : ReactiveUI.INotifyCollectionChanging, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, ReactiveUI.Legacy.IReactiveCollection<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionChanged<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionItemChanged<T>, Splat.IEnableLogger, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged
    {
        bool IsEmpty { get; }
        void AddRange(System.Collections.Generic.IEnumerable<T> collection);
        void InsertRange(int index, System.Collections.Generic.IEnumerable<T> collection);
        void RemoveAll(System.Collections.Generic.IEnumerable<T> items);
        void RemoveRange(int index, int count);
        void Sort(System.Collections.Generic.IComparer<T> comparer = null);
        void Sort(System.Comparison<T> comparison);
        void Sort(int index, int count, System.Collections.Generic.IComparer<T> comparer);
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReactiveNotifyCollectionChanged<out T>
    {
        System.IObservable<T> BeforeItemsAdded { get; }
        System.IObservable<ReactiveUI.Legacy.IMoveInfo<T>> BeforeItemsMoved { get; }
        System.IObservable<T> BeforeItemsRemoved { get; }
        System.IObservable<System.Collections.Specialized.NotifyCollectionChangedEventArgs> Changed { get; }
        System.IObservable<System.Collections.Specialized.NotifyCollectionChangedEventArgs> Changing { get; }
        System.IObservable<int> CountChanged { get; }
        System.IObservable<int> CountChanging { get; }
        System.IObservable<bool> IsEmptyChanged { get; }
        System.IObservable<T> ItemsAdded { get; }
        System.IObservable<ReactiveUI.Legacy.IMoveInfo<T>> ItemsMoved { get; }
        System.IObservable<T> ItemsRemoved { get; }
        System.IObservable<System.Reactive.Unit> ShouldReset { get; }
        System.IDisposable SuppressChangeNotifications();
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReactiveNotifyCollectionItemChanged<out TSender>
    {
        bool ChangeTrackingEnabled { get; set; }
        System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<TSender>> ItemChanged { get; }
        System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<TSender>> ItemChanging { get; }
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReadOnlyReactiveCollection<out T> : ReactiveUI.INotifyCollectionChanging, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, ReactiveUI.Legacy.IReactiveCollection<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionChanged<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionItemChanged<T>, Splat.IEnableLogger, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged { }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public interface IReadOnlyReactiveList<out T> : ReactiveUI.INotifyCollectionChanging, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, ReactiveUI.Legacy.IReactiveCollection<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionChanged<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionItemChanged<T>, ReactiveUI.Legacy.IReadOnlyReactiveCollection<T>, Splat.IEnableLogger, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged
    {
        bool IsEmpty { get; }
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public class static ObservableCollectionMixin
    {
        public static ReactiveUI.Legacy.IReactiveDerivedList<TNew> CreateDerivedCollection<T, TNew, TDontCare>(this System.Collections.Generic.IEnumerable<T> @this, System.Func<T, TNew> selector, System.Action<TNew> onRemoved, System.Func<T, bool> filter = null, System.Func<TNew, TNew, int> orderer = null, System.IObservable<TDontCare> signalReset = null, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public static ReactiveUI.Legacy.IReactiveDerivedList<TNew> CreateDerivedCollection<T, TNew, TDontCare>(this System.Collections.Generic.IEnumerable<T> @this, System.Func<T, TNew> selector, System.Func<T, bool> filter = null, System.Func<TNew, TNew, int> orderer = null, System.IObservable<TDontCare> signalReset = null, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public static ReactiveUI.Legacy.IReactiveDerivedList<TNew> CreateDerivedCollection<T, TNew>(this System.Collections.Generic.IEnumerable<T> @this, System.Func<T, TNew> selector, System.Action<TNew> onRemoved, System.Func<T, bool> filter = null, System.Func<TNew, TNew, int> orderer = null, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public static ReactiveUI.Legacy.IReactiveDerivedList<TNew> CreateDerivedCollection<T, TNew>(this System.Collections.Generic.IEnumerable<T> @this, System.Func<T, TNew> selector, System.Func<T, bool> filter = null, System.Func<TNew, TNew, int> orderer = null, System.Reactive.Concurrency.IScheduler scheduler = null) { }
    }
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public class static ReactiveCollectionMixins
    {
        public static ReactiveUI.Legacy.IReactiveDerivedList<T> CreateCollection<T>(this System.IObservable<T> fromObservable, System.Reactive.Concurrency.IScheduler scheduler) { }
        public static ReactiveUI.Legacy.IReactiveDerivedList<T> CreateCollection<T>(this System.IObservable<T> fromObservable, System.Nullable<System.TimeSpan> withDelay = null, System.Action<System.Exception> onError = null, System.Reactive.Concurrency.IScheduler scheduler = null) { }
    }
    [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
    [System.Diagnostics.DebuggerTypeProxyAttribute(typeof(ReactiveUI.CollectionDebugView<>))]
    [System.ObsoleteAttribute("ReactiveList is no longer supported. We suggest replacing it with DynamicData htt" +
        "ps://github.com/rolandpheasant/dynamicdata")]
    public class ReactiveList<T> : ReactiveUI.INotifyCollectionChanging, ReactiveUI.INotifyPropertyChanging, ReactiveUI.IReactiveObject, ReactiveUI.Legacy.IReactiveCollection<T>, ReactiveUI.Legacy.IReactiveList<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionChanged<T>, ReactiveUI.Legacy.IReactiveNotifyCollectionItemChanged<T>, ReactiveUI.Legacy.IReadOnlyReactiveCollection<T>, ReactiveUI.Legacy.IReadOnlyReactiveList<T>, Splat.IEnableLogger, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged
    {
        public ReactiveList() { }
        public ReactiveList(System.Collections.Generic.IEnumerable<T> initialContents) { }
        public ReactiveList(System.Collections.Generic.IEnumerable<T> initialContents = null, double resetChangeThreshold = 0.3, System.Reactive.Concurrency.IScheduler scheduler = null) { }
        public System.IObservable<T> BeforeItemsAdded { get; }
        public System.IObservable<ReactiveUI.Legacy.IMoveInfo<T>> BeforeItemsMoved { get; }
        public System.IObservable<T> BeforeItemsRemoved { get; }
        public System.IObservable<System.Collections.Specialized.NotifyCollectionChangedEventArgs> Changed { get; }
        public bool ChangeTrackingEnabled { get; set; }
        public System.IObservable<System.Collections.Specialized.NotifyCollectionChangedEventArgs> Changing { get; }
        public int Count { get; }
        public System.IObservable<int> CountChanged { get; }
        public System.IObservable<int> CountChanging { get; }
        public bool IsEmpty { get; }
        public System.IObservable<bool> IsEmptyChanged { get; }
        public virtual bool IsReadOnly { get; }
        public virtual T this[int index] { get; set; }
        public System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<T>> ItemChanged { get; }
        public System.IObservable<ReactiveUI.IReactivePropertyChangedEventArgs<T>> ItemChanging { get; }
        public System.IObservable<T> ItemsAdded { get; }
        public System.IObservable<ReactiveUI.Legacy.IMoveInfo<T>> ItemsMoved { get; }
        public System.IObservable<T> ItemsRemoved { get; }
        [System.Runtime.Serialization.IgnoreDataMemberAttribute()]
        public double ResetChangeThreshold { get; set; }
        public System.IObservable<System.Reactive.Unit> ShouldReset { get; }
        public event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged;
        public event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanging;
        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        public event ReactiveUI.PropertyChangingEventHandler PropertyChanging;
        public virtual void Add(T item) { }
        public virtual void AddRange(System.Collections.Generic.IEnumerable<T> collection) { }
        public int BinarySearch(T item) { }
        public int BinarySearch(T item, System.Collections.Generic.IComparer<T> comparer) { }
        public int BinarySearch(int index, int count, T item, System.Collections.Generic.IComparer<T> comparer) { }
        public virtual void Clear() { }
        protected void ClearItems() { }
        public bool Contains(T item) { }
        public void CopyTo(T[] array, int arrayIndex) { }
        public System.Collections.Generic.IEnumerator<T> GetEnumerator() { }
        public int IndexOf(T item) { }
        public virtual void Insert(int index, T item) { }
        protected void InsertItem(int index, T item) { }
        public virtual void InsertRange(int index, System.Collections.Generic.IEnumerable<T> collection) { }
        public virtual void Move(int oldIndex, int newIndex) { }
        protected void MoveItem(int oldIndex, int newIndex) { }
        protected virtual void RaiseCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs args) { }
        protected virtual void RaiseCollectionChanging(System.Collections.Specialized.NotifyCollectionChangedEventArgs args) { }
        public virtual bool Remove(T item) { }
        public virtual void RemoveAll(System.Collections.Generic.IEnumerable<T> items) { }
        public virtual void RemoveAt(int index) { }
        protected void RemoveItem(int index) { }
        public virtual void RemoveRange(int index, int count) { }
        public virtual void Reset() { }
        protected void SetItem(int index, T item) { }
        public virtual void Sort(int index, int count, System.Collections.Generic.IComparer<T> comparer) { }
        public virtual void Sort(System.Comparison<T> comparison) { }
        public virtual void Sort(System.Collections.Generic.IComparer<T> comparer = null) { }
        public System.IDisposable SuppressChangeNotifications() { }
    }
}
namespace System.Reactive.Disposables
{
    public class static DisposableMixins { }
}